493c20365a6d47dbf69371f8fd135bde2c229dc9054e566c25aaf8d2b87e7c2f

a1111-microsoftexcel-locon/README.md

@@ -0,0 +1,42 @@
+# a1111-sd-webui-locon
+
+An extension for loading lycoris model in sd-webui. (include locon and loha)
+
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+# THIS EXTENSION IS NOT FOR ADDITIONAL NETWORK
+
+### LyCORIS
+https://github.com/KohakuBlueleaf/LyCORIS
+
+### usage
+Install and use locon model as lora model. <br>
+Make sure your sd-webui has built-in lora
+
+![image](https://user-images.githubusercontent.com/59680068/222327303-9ba4f702-5821-48db-a849-337dce9b11bb.png)

a1111-microsoftexcel-locon/locon.py

@@ -0,0 +1,57 @@
+'''
+https://github.com/KohakuBlueleaf/LoCon
+'''
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class LoConModule(nn.Module):
+    """
+    modifed from kohya-ss/sd-scripts/networks/lora:LoRAModule
+    """
+
+    def __init__(self, lora_name, org_module: nn.Module, multiplier=1.0, lora_dim=4, alpha=1):
+        """ if alpha == 0 or None, alpha is rank (no scaling). """
+        super().__init__()
+        self.lora_name = lora_name
+        self.lora_dim = lora_dim
+
+        if org_module.__class__.__name__ == 'Conv2d':
+            # For general LoCon
+            in_dim = org_module.in_channels
+            k_size = org_module.kernel_size
+            stride = org_module.stride
+            padding = org_module.padding
+            out_dim = org_module.out_channels
+            self.lora_down = nn.Conv2d(in_dim, lora_dim, k_size, stride, padding, bias=False)
+            self.lora_up = nn.Conv2d(lora_dim, out_dim, (1, 1), bias=False)
+        else:
+            in_dim = org_module.in_features
+            out_dim = org_module.out_features
+            self.lora_down = nn.Linear(in_dim, lora_dim, bias=False)
+            self.lora_up = nn.Linear(lora_dim, out_dim, bias=False)
+
+        if type(alpha) == torch.Tensor:
+            alpha = alpha.detach().float().numpy()  # without casting, bf16 causes error
+        alpha = lora_dim if alpha is None or alpha == 0 else alpha
+        self.scale = alpha / self.lora_dim
+        self.register_buffer('alpha', torch.tensor(alpha)) # 定数として扱える
+
+        # same as microsoft's
+        torch.nn.init.kaiming_uniform_(self.lora_down.weight, a=math.sqrt(5))
+        torch.nn.init.zeros_(self.lora_up.weight)
+
+        self.multiplier = multiplier
+        self.org_module = org_module # remove in applying
+
+    def apply_to(self):
+        self.org_forward = self.org_module.forward
+        self.org_module.forward = self.forward
+        del self.org_module
+
+    def forward(self, x):
+        return self.org_forward(x) + self.lora_up(self.lora_down(x)) * self.multiplier * self.scale

a1111-microsoftexcel-locon/locon_compvis.py

@@ -0,0 +1,488 @@
+'''
+Hijack version of kohya-ss/additional_networks/scripts/lora_compvis.py
+'''
+# LoRA network module
+# reference:
+# https://github.com/microsoft/LoRA/blob/main/loralib/layers.py
+# https://github.com/cloneofsimo/lora/blob/master/lora_diffusion/lora.py
+
+import copy
+import math
+import re
+from typing import NamedTuple
+import torch
+from locon import LoConModule
+
+
+class LoRAInfo(NamedTuple):
+    lora_name: str
+    module_name: str
+    module: torch.nn.Module
+    multiplier: float
+    dim: int
+    alpha: float
+
+
+def create_network_and_apply_compvis(du_state_dict, multiplier_tenc, multiplier_unet, text_encoder, unet, **kwargs):
+    # get device and dtype from unet
+    for module in unet.modules():
+        if module.__class__.__name__ == "Linear":
+            param: torch.nn.Parameter = module.weight
+            # device = param.device
+            dtype = param.dtype
+            break
+
+    # get dims (rank) and alpha from state dict
+    # currently it is assumed all LoRA have same alpha. alpha may be different in future.
+    network_alpha = None
+    conv_alpha = None
+    network_dim = None
+    conv_dim = None
+    for key, value in du_state_dict.items():
+        if network_alpha is None and 'alpha' in key:
+            network_alpha = value
+        if network_dim is None and 'lora_down' in key and len(value.size()) == 2:
+            network_dim = value.size()[0]
+        if network_alpha is not None and network_dim is not None:
+            break
+    if network_alpha is None:
+        network_alpha = network_dim
+
+    print(f"dimension: {network_dim},\n"
+          f"alpha: {network_alpha},\n"
+          f"multiplier_unet: {multiplier_unet},\n"
+          f"multiplier_tenc: {multiplier_tenc}"
+          )
+    if network_dim is None:
+        print(f"The selected model is not LoRA or not trained by `sd-scripts`?")
+        network_dim = 4
+        network_alpha = 1
+
+    # create, apply and load weights
+    network = LoConNetworkCompvis(
+        text_encoder, unet, du_state_dict,
+        multiplier_tenc = multiplier_tenc,
+        multiplier_unet = multiplier_unet,
+    )
+    state_dict = network.apply_lora_modules(du_state_dict)              # some weights are applied to text encoder
+    network.to(dtype)                                              # with this, if error comes from next line, the model will be used
+    info = network.load_state_dict(state_dict, strict=False)
+
+    # remove redundant warnings
+    if len(info.missing_keys) > 4:
+        missing_keys = []
+        alpha_count = 0
+        for key in info.missing_keys:
+            if 'alpha' not in key:
+                missing_keys.append(key)
+            else:
+                if alpha_count == 0:
+                    missing_keys.append(key)
+                alpha_count += 1
+        if alpha_count > 1:
+            missing_keys.append(
+                    f"... and {alpha_count-1} alphas. The model doesn't have alpha, use dim (rannk) as alpha. You can ignore this message.")
+
+        info = torch.nn.modules.module._IncompatibleKeys(missing_keys, info.unexpected_keys)
+
+    return network, info
+
+
+class LoConNetworkCompvis(torch.nn.Module):
+    # UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"]
+    # TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"]
+    LOCON_TARGET = ["ResBlock", "Downsample", "Upsample"]
+    UNET_TARGET_REPLACE_MODULE = ["SpatialTransformer"] + LOCON_TARGET  # , "Attention"]
+    TEXT_ENCODER_TARGET_REPLACE_MODULE = ["ResidualAttentionBlock", "CLIPAttention", "CLIPMLP"]
+
+    LORA_PREFIX_UNET = 'lora_unet'
+    LORA_PREFIX_TEXT_ENCODER = 'lora_te'
+
+    @classmethod
+    def convert_diffusers_name_to_compvis(cls, v2, du_name):
+        """
+        convert diffusers's LoRA name to CompVis
+        """
+        cv_name = None
+        if "lora_unet_" in du_name:
+            m = re.search(r"_down_blocks_(\d+)_attentions_(\d+)_(.+)", du_name)
+            if m:
+                du_block_index = int(m.group(1))
+                du_attn_index = int(m.group(2))
+                du_suffix = m.group(3)
+
+                cv_index = 1 + du_block_index * 3 + du_attn_index      # 1,2, 4,5, 7,8
+                cv_name = f"lora_unet_input_blocks_{cv_index}_1_{du_suffix}"
+                return cv_name
+            
+            m = re.search(r"_mid_block_attentions_(\d+)_(.+)", du_name)
+            if m:
+                du_suffix = m.group(2)
+                cv_name = f"lora_unet_middle_block_1_{du_suffix}"
+                return cv_name
+            
+            m = re.search(r"_up_blocks_(\d+)_attentions_(\d+)_(.+)", du_name)
+            if m:
+                du_block_index = int(m.group(1))
+                du_attn_index = int(m.group(2))
+                du_suffix = m.group(3)
+
+                cv_index = du_block_index * 3 + du_attn_index      # 3,4,5, 6,7,8, 9,10,11
+                cv_name = f"lora_unet_output_blocks_{cv_index}_1_{du_suffix}"
+                return cv_name
+            
+            m = re.search(r"_down_blocks_(\d+)_resnets_(\d+)_(.+)", du_name)
+            if m:
+                du_block_index = int(m.group(1))
+                du_res_index = int(m.group(2))
+                du_suffix = m.group(3)
+                cv_suffix = {
+                    'conv1': 'in_layers_2',
+                    'conv2': 'out_layers_3',
+                    'time_emb_proj': 'emb_layers_1',
+                    'conv_shortcut': 'skip_connection'
+                }[du_suffix]
+
+                cv_index = 1 + du_block_index * 3 + du_res_index      # 1,2, 4,5, 7,8
+                cv_name = f"lora_unet_input_blocks_{cv_index}_0_{cv_suffix}"
+                return cv_name
+            
+            m = re.search(r"_down_blocks_(\d+)_downsamplers_0_conv", du_name)
+            if m:
+                block_index = int(m.group(1))
+                cv_index = 3 + block_index * 3
+                cv_name = f"lora_unet_input_blocks_{cv_index}_0_op"
+                return cv_name
+            
+            m = re.search(r"_mid_block_resnets_(\d+)_(.+)", du_name)
+            if m:
+                index = int(m.group(1))
+                du_suffix = m.group(2)
+                cv_suffix = {
+                    'conv1': 'in_layers_2',
+                    'conv2': 'out_layers_3',
+                    'time_emb_proj': 'emb_layers_1',
+                    'conv_shortcut': 'skip_connection'
+                }[du_suffix]
+                cv_name = f"lora_unet_middle_block_{index*2}_{cv_suffix}"
+                return cv_name
+            
+            m = re.search(r"_up_blocks_(\d+)_resnets_(\d+)_(.+)", du_name)
+            if m:
+                du_block_index = int(m.group(1))
+                du_res_index = int(m.group(2))
+                du_suffix = m.group(3)
+                cv_suffix = {
+                    'conv1': 'in_layers_2',
+                    'conv2': 'out_layers_3',
+                    'time_emb_proj': 'emb_layers_1',
+                    'conv_shortcut': 'skip_connection'
+                }[du_suffix]
+
+                cv_index = du_block_index * 3 + du_res_index      # 1,2, 4,5, 7,8
+                cv_name = f"lora_unet_output_blocks_{cv_index}_0_{cv_suffix}"
+                return cv_name
+            
+            m = re.search(r"_up_blocks_(\d+)_upsamplers_0_conv", du_name)
+            if m:
+                block_index = int(m.group(1))
+                cv_index = block_index * 3 + 2
+                cv_name = f"lora_unet_output_blocks_{cv_index}_{bool(block_index)+1}_conv"
+                return cv_name
+            
+        elif "lora_te_" in du_name:
+            m = re.search(r"_model_encoder_layers_(\d+)_(.+)", du_name)
+            if m:
+                du_block_index = int(m.group(1))
+                du_suffix = m.group(2)
+
+                cv_index = du_block_index
+                if v2:
+                    if 'mlp_fc1' in du_suffix:
+                        cv_name = f"lora_te_wrapped_model_transformer_resblocks_{cv_index}_{du_suffix.replace('mlp_fc1', 'mlp_c_fc')}"
+                    elif 'mlp_fc2' in du_suffix:
+                        cv_name = f"lora_te_wrapped_model_transformer_resblocks_{cv_index}_{du_suffix.replace('mlp_fc2', 'mlp_c_proj')}"
+                    elif 'self_attn':
+                        # handled later
+                        cv_name = f"lora_te_wrapped_model_transformer_resblocks_{cv_index}_{du_suffix.replace('self_attn', 'attn')}"
+                else:
+                    cv_name = f"lora_te_wrapped_transformer_text_model_encoder_layers_{cv_index}_{du_suffix}"
+
+        assert cv_name is not None, f"conversion failed: {du_name}. the model may not be trained by `sd-scripts`."
+        return cv_name
+
+    @classmethod
+    def convert_state_dict_name_to_compvis(cls, v2, state_dict):
+        """
+        convert keys in state dict to load it by load_state_dict
+        """
+        new_sd = {}
+        for key, value in state_dict.items():
+            tokens = key.split('.')
+            compvis_name = LoConNetworkCompvis.convert_diffusers_name_to_compvis(v2, tokens[0])
+            new_key = compvis_name + '.' + '.'.join(tokens[1:])
+            new_sd[new_key] = value
+
+        return new_sd
+
+    def __init__(self, text_encoder, unet, du_state_dict, multiplier_tenc=1.0, multiplier_unet=1.0) -> None:
+        super().__init__()
+        self.multiplier_unet = multiplier_unet
+        self.multiplier_tenc = multiplier_tenc
+
+        # create module instances
+        for name, module in text_encoder.named_modules():
+            for child_name, child_module in module.named_modules():
+                if child_module.__class__.__name__ == 'MultiheadAttention':
+                    self.v2 = True
+                    break
+            else:
+                continue
+            break
+        else:
+            self.v2 = False
+        comp_state_dict = {}
+
+        def create_modules(prefix, root_module: torch.nn.Module, target_replace_modules, multiplier):
+            nonlocal comp_state_dict
+            loras = []
+            replaced_modules = []
+            for name, module in root_module.named_modules():
+                if module.__class__.__name__ in target_replace_modules:
+                    for child_name, child_module in module.named_modules():
+                        layer = child_module.__class__.__name__
+                        lora_name = prefix + '.' + name + '.' + child_name
+                        lora_name = lora_name.replace('.', '_')
+                        if layer == "Linear" or layer == "Conv2d":
+                            if '_resblocks_23_' in lora_name:  # ignore last block in StabilityAi Text Encoder
+                                break
+                            if f'{lora_name}.lora_down.weight' not in comp_state_dict:
+                                if module.__class__.__name__ in LoConNetworkCompvis.LOCON_TARGET:
+                                    continue
+                                else:
+                                    print(f'Cannot find: "{lora_name}", skipped')
+                                    continue
+                            rank = comp_state_dict[f'{lora_name}.lora_down.weight'].shape[0]
+                            alpha = comp_state_dict.get(f'{lora_name}.alpha', torch.tensor(rank)).item()
+                            lora = LoConModule(lora_name, child_module, multiplier, rank, alpha)
+                            loras.append(lora)
+
+                            replaced_modules.append(child_module)
+                        elif child_module.__class__.__name__ == "MultiheadAttention":
+                            # make four modules: not replacing forward method but merge weights
+                            self.v2 = True
+                            for suffix in ['q', 'k', 'v', 'out']:
+                                module_name = prefix + '.' + name + '.' + child_name          # ~.attn
+                                module_name = module_name.replace('.', '_')
+                                if '_resblocks_23_' in module_name:                           # ignore last block in StabilityAi Text Encoder
+                                    break
+                                lora_name = module_name + '_' + suffix
+                                lora_info = LoRAInfo(lora_name, module_name, child_module, multiplier, 0, 0)
+                                loras.append(lora_info)
+
+                                replaced_modules.append(child_module)
+            return loras, replaced_modules
+        
+        for k,v in LoConNetworkCompvis.convert_state_dict_name_to_compvis(self.v2, du_state_dict).items():
+            comp_state_dict[k] = v
+
+        self.text_encoder_loras, te_rep_modules = create_modules(
+            LoConNetworkCompvis.LORA_PREFIX_TEXT_ENCODER,
+            text_encoder, 
+            LoConNetworkCompvis.TEXT_ENCODER_TARGET_REPLACE_MODULE, 
+            self.multiplier_tenc
+        )
+        print(f"create LoCon for Text Encoder: {len(self.text_encoder_loras)} modules.")
+        
+        self.unet_loras, unet_rep_modules = create_modules(
+            LoConNetworkCompvis.LORA_PREFIX_UNET, 
+            unet, 
+            LoConNetworkCompvis.UNET_TARGET_REPLACE_MODULE, 
+            self.multiplier_unet
+        )
+        print(f"create LoCon for U-Net: {len(self.unet_loras)} modules.")
+
+        # make backup of original forward/weights, if multiple modules are applied, do in 1st module only
+        backed_up = False                     # messaging purpose only
+        for rep_module in te_rep_modules + unet_rep_modules:
+            if rep_module.__class__.__name__ == "MultiheadAttention":      # multiple MHA modules are in list, prevent to backed up forward
+                if not hasattr(rep_module, "_lora_org_weights"):
+                    # avoid updating of original weights. state_dict is reference to original weights
+                    rep_module._lora_org_weights = copy.deepcopy(rep_module.state_dict())
+                    backed_up = True
+            elif not hasattr(rep_module, "_lora_org_forward"):
+                rep_module._lora_org_forward = rep_module.forward
+                backed_up = True
+        if backed_up:
+            print("original forward/weights is backed up.")
+
+        # assertion
+        names = set()
+        for lora in self.text_encoder_loras + self.unet_loras:
+            assert lora.lora_name not in names, f"duplicated lora name: {lora.lora_name}"
+            names.add(lora.lora_name)
+
+    def restore(self, text_encoder, unet):
+        # restore forward/weights from property for all modules
+        restored = False                        # messaging purpose only
+        modules = []
+        modules.extend(text_encoder.modules())
+        modules.extend(unet.modules())
+        for module in modules:
+            if hasattr(module, "_lora_org_forward"):
+                module.forward = module._lora_org_forward
+                del module._lora_org_forward
+                restored = True
+            if hasattr(module, "_lora_org_weights"):        # module doesn't have forward and weights at same time currently, but supports it for future changing
+                module.load_state_dict(module._lora_org_weights)
+                del module._lora_org_weights
+                restored = True
+
+        if restored:
+            print("original forward/weights is restored.")
+
+    def apply_lora_modules(self, du_state_dict):
+        # conversion 1st step: convert names in state_dict
+        state_dict = LoConNetworkCompvis.convert_state_dict_name_to_compvis(self.v2, du_state_dict)
+
+        # check state_dict has text_encoder or unet
+        weights_has_text_encoder = weights_has_unet = False
+        for key in state_dict.keys():
+            if key.startswith(LoConNetworkCompvis.LORA_PREFIX_TEXT_ENCODER):
+                weights_has_text_encoder = True
+            elif key.startswith(LoConNetworkCompvis.LORA_PREFIX_UNET):
+                weights_has_unet = True
+            if weights_has_text_encoder and weights_has_unet:
+                break
+
+        apply_text_encoder = weights_has_text_encoder
+        apply_unet = weights_has_unet
+
+        if apply_text_encoder:
+            print("enable LoCon for text encoder")
+        else:
+            self.text_encoder_loras = []
+
+        if apply_unet:
+            print("enable LoCon for U-Net")
+        else:
+            self.unet_loras = []
+
+        # add modules to network: this makes state_dict can be got from LoRANetwork
+        mha_loras = {}
+        for lora in self.text_encoder_loras + self.unet_loras:
+            if type(lora) == LoConModule:
+                lora.apply_to()                           # ensure remove reference to original Linear: reference makes key of state_dict
+                self.add_module(lora.lora_name, lora)
+            else:
+                # SD2.x MultiheadAttention merge weights to MHA weights
+                lora_info: LoRAInfo = lora
+                if lora_info.module_name not in mha_loras:
+                    mha_loras[lora_info.module_name] = {}
+
+                lora_dic = mha_loras[lora_info.module_name]
+                lora_dic[lora_info.lora_name] = lora_info
+                if len(lora_dic) == 4:
+                    # calculate and apply
+                    w_q_dw = state_dict.get(lora_info.module_name + '_q_proj.lora_down.weight')
+                    if w_q_dw is not None:                       # corresponding LoRa module exists
+                        w_q_up = state_dict[lora_info.module_name + '_q_proj.lora_up.weight']
+                        w_q_ap = state_dict.get(lora_info.module_name + '_q_proj.alpha', None)
+                        w_k_dw = state_dict[lora_info.module_name + '_k_proj.lora_down.weight']
+                        w_k_up = state_dict[lora_info.module_name + '_k_proj.lora_up.weight']
+                        w_k_ap = state_dict.get(lora_info.module_name + '_k_proj.alpha', None)
+                        w_v_dw = state_dict[lora_info.module_name + '_v_proj.lora_down.weight']
+                        w_v_up = state_dict[lora_info.module_name + '_v_proj.lora_up.weight']
+                        w_v_ap = state_dict.get(lora_info.module_name + '_v_proj.alpha', None)
+                        w_out_dw = state_dict[lora_info.module_name + '_out_proj.lora_down.weight']
+                        w_out_up = state_dict[lora_info.module_name + '_out_proj.lora_up.weight']
+                        w_out_ap = state_dict.get(lora_info.module_name + '_out_proj.alpha', None)
+
+                        sd = lora_info.module.state_dict()
+                        qkv_weight = sd['in_proj_weight']
+                        out_weight = sd['out_proj.weight']
+                        dev = qkv_weight.device
+
+                        def merge_weights(weight, up_weight, down_weight, alpha=None):
+                            # calculate in float
+                            if alpha is None:
+                                alpha = down_weight.shape[0]
+                            alpha = float(alpha)
+                            scale = alpha / down_weight.shape[0]
+                            dtype = weight.dtype
+                            weight = weight.float() + lora_info.multiplier * (up_weight.to(dev, dtype=torch.float) @ down_weight.to(dev, dtype=torch.float)) * scale
+                            weight = weight.to(dtype)
+                            return weight
+
+                        q_weight, k_weight, v_weight = torch.chunk(qkv_weight, 3)
+                        if q_weight.size()[1] == w_q_up.size()[0]:
+                            q_weight = merge_weights(q_weight, w_q_up, w_q_dw, w_q_ap)
+                            k_weight = merge_weights(k_weight, w_k_up, w_k_dw, w_k_ap)
+                            v_weight = merge_weights(v_weight, w_v_up, w_v_dw, w_v_ap)
+                            qkv_weight = torch.cat([q_weight, k_weight, v_weight])
+
+                            out_weight = merge_weights(out_weight, w_out_up, w_out_dw, w_out_ap)
+
+                            sd['in_proj_weight'] = qkv_weight.to(dev)
+                            sd['out_proj.weight'] = out_weight.to(dev)
+
+                            lora_info.module.load_state_dict(sd)
+                        else:
+                            # different dim, version mismatch
+                            print(f"shape of weight is different: {lora_info.module_name}. SD version may be different")
+
+                        for t in ["q", "k", "v", "out"]:
+                            del state_dict[f"{lora_info.module_name}_{t}_proj.lora_down.weight"]
+                            del state_dict[f"{lora_info.module_name}_{t}_proj.lora_up.weight"]
+                            alpha_key = f"{lora_info.module_name}_{t}_proj.alpha"
+                            if alpha_key in state_dict:
+                                del state_dict[alpha_key]
+                    else:
+                        # corresponding weight not exists: version mismatch
+                        pass
+
+        # conversion 2nd step: convert weight's shape (and handle wrapped)
+        state_dict = self.convert_state_dict_shape_to_compvis(state_dict)
+
+        return state_dict
+
+    def convert_state_dict_shape_to_compvis(self, state_dict):
+        # shape conversion
+        current_sd = self.state_dict()        # to get target shape
+        wrapped = False
+        count = 0
+        for key in list(state_dict.keys()):
+            if key not in current_sd:
+                continue                          # might be error or another version
+            if "wrapped" in key:
+                wrapped = True
+
+            value: torch.Tensor = state_dict[key]
+            if value.size() != current_sd[key].size():
+                # print(key, value.size(), current_sd[key].size())
+                # print(f"convert weights shape: {key}, from: {value.size()}, {len(value.size())}")
+                count += 1
+                if '.alpha' in key:
+                    assert value.size().numel() == 1
+                    value = torch.tensor(value.item())
+                elif len(value.size()) == 4:
+                    value = value.squeeze(3).squeeze(2)
+                else:
+                    value = value.unsqueeze(2).unsqueeze(3)
+                state_dict[key] = value
+            if tuple(value.size()) != tuple(current_sd[key].size()):
+                print(
+                        f"weight's shape is different: {key} expected {current_sd[key].size()} found {value.size()}. SD version may be different")
+                del state_dict[key]
+        print(f"shapes for {count} weights are converted.")
+
+        # convert wrapped
+        if not wrapped:
+            print("remove 'wrapped' from keys")
+            for key in list(state_dict.keys()):
+                if "_wrapped_" in key:
+                    new_key = key.replace("_wrapped_", "_")
+                    state_dict[new_key] = state_dict[key]
+                    del state_dict[key]
+
+        return state_dict

a1111-microsoftexcel-locon/scripts/main.py

@@ -0,0 +1,766 @@
+'''
+Modified version for full net lora
+(Lora for ResBlock and up/down sample block)
+'''
+import os, sys
+import re
+import torch
+
+from modules import shared, devices, sd_models
+now_dir = os.path.dirname(os.path.abspath(__file__))
+lora_path = os.path.join(now_dir, '..', '..', '..', 'extensions-builtin/Lora')
+sys.path.insert(0, lora_path)
+import lora
+new_lora = 'lora_calc_updown' in dir(lora)
+
+from locon_compvis import LoConModule, LoConNetworkCompvis, create_network_and_apply_compvis
+
+
+try:
+    '''
+    Hijack Additional Network extension
+    '''
+    # skip addnet since don't support new version
+    raise
+    now_dir = os.path.dirname(os.path.abspath(__file__))
+    addnet_path = os.path.join(now_dir, '..', '..', 'sd-webui-additional-networks/scripts')
+    sys.path.append(addnet_path)
+    import lora_compvis
+    import scripts
+    scripts.lora_compvis = lora_compvis
+    scripts.lora_compvis.LoRAModule = LoConModule
+    scripts.lora_compvis.LoRANetworkCompvis = LoConNetworkCompvis
+    scripts.lora_compvis.create_network_and_apply_compvis = create_network_and_apply_compvis
+    print('LoCon Extension hijack addnet extension successfully')
+except:
+    print('Additional Network extension not installed, Only hijack built-in lora')
+
+
+'''
+Hijack sd-webui LoRA
+'''
+re_digits = re.compile(r"\d+")
+re_x_proj = re.compile(r"(.*)_([qkv]_proj)$")
+
+re_unet_conv_in = re.compile(r"lora_unet_conv_in(.+)")
+re_unet_conv_out = re.compile(r"lora_unet_conv_out(.+)")
+re_unet_time_embed = re.compile(r"lora_unet_time_embedding_linear_(\d+)(.+)")
+
+re_unet_down_blocks = re.compile(r"lora_unet_down_blocks_(\d+)_attentions_(\d+)_(.+)")
+re_unet_mid_blocks = re.compile(r"lora_unet_mid_block_attentions_(\d+)_(.+)")
+re_unet_up_blocks = re.compile(r"lora_unet_up_blocks_(\d+)_attentions_(\d+)_(.+)")
+
+re_unet_down_blocks_res = re.compile(r"lora_unet_down_blocks_(\d+)_resnets_(\d+)_(.+)")
+re_unet_mid_blocks_res = re.compile(r"lora_unet_mid_block_resnets_(\d+)_(.+)")
+re_unet_up_blocks_res = re.compile(r"lora_unet_up_blocks_(\d+)_resnets_(\d+)_(.+)")
+
+re_unet_downsample = re.compile(r"lora_unet_down_blocks_(\d+)_downsamplers_0_conv(.+)")
+re_unet_upsample = re.compile(r"lora_unet_up_blocks_(\d+)_upsamplers_0_conv(.+)")
+
+re_text_block = re.compile(r"lora_te_text_model_encoder_layers_(\d+)_(.+)")
+
+
+def convert_diffusers_name_to_compvis(key, is_sd2):
+    # I don't know why but some state dict has this kind of thing
+    key = key.replace('text_model_text_model', 'text_model')
+    def match(match_list, regex):
+        r = re.match(regex, key)
+        if not r:
+            return False
+
+        match_list.clear()
+        match_list.extend([int(x) if re.match(re_digits, x) else x for x in r.groups()])
+        return True
+
+    m = []
+    
+    if match(m, re_unet_conv_in):
+        return f'diffusion_model_input_blocks_0_0{m[0]}'
+    
+    if match(m, re_unet_conv_out):
+        return f'diffusion_model_out_2{m[0]}'
+    
+    if match(m, re_unet_time_embed):
+        return f"diffusion_model_time_embed_{m[0]*2-2}{m[1]}"
+    
+    if match(m, re_unet_down_blocks):
+        return f"diffusion_model_input_blocks_{1 + m[0] * 3 + m[1]}_1_{m[2]}"
+
+    if match(m, re_unet_mid_blocks):
+        return f"diffusion_model_middle_block_1_{m[1]}"
+
+    if match(m, re_unet_up_blocks):
+        return f"diffusion_model_output_blocks_{m[0] * 3 + m[1]}_1_{m[2]}"
+
+    if match(m, re_unet_down_blocks_res):
+        block = f"diffusion_model_input_blocks_{1 + m[0] * 3 + m[1]}_0_"
+        if m[2].startswith('conv1'):
+            return f"{block}in_layers_2{m[2][len('conv1'):]}"
+        elif m[2].startswith('conv2'):
+            return f"{block}out_layers_3{m[2][len('conv2'):]}"
+        elif m[2].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[2][len('time_emb_proj'):]}"
+        elif m[2].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[2][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_mid_blocks_res):
+        block = f"diffusion_model_middle_block_{m[0]*2}_"
+        if m[1].startswith('conv1'):
+            return f"{block}in_layers_2{m[1][len('conv1'):]}"
+        elif m[1].startswith('conv2'):
+            return f"{block}out_layers_3{m[1][len('conv2'):]}"
+        elif m[1].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[1][len('time_emb_proj'):]}"
+        elif m[1].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[1][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_up_blocks_res):
+        block = f"diffusion_model_output_blocks_{m[0] * 3 + m[1]}_0_"
+        if m[2].startswith('conv1'):
+            return f"{block}in_layers_2{m[2][len('conv1'):]}"
+        elif m[2].startswith('conv2'):
+            return f"{block}out_layers_3{m[2][len('conv2'):]}"
+        elif m[2].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[2][len('time_emb_proj'):]}"
+        elif m[2].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[2][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_downsample):
+        return f"diffusion_model_input_blocks_{m[0]*3+3}_0_op{m[1]}"
+
+    if match(m, re_unet_upsample):
+        return f"diffusion_model_output_blocks_{m[0]*3 + 2}_{1+(m[0]!=0)}_conv{m[1]}"
+
+    if match(m, r"lora_te_text_model_encoder_layers_(\d+)_(.+)"):
+        if is_sd2:
+            if 'mlp_fc1' in m[1]:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('mlp_fc1', 'mlp_c_fc')}"
+            elif 'mlp_fc2' in m[1]:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('mlp_fc2', 'mlp_c_proj')}"
+            else:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('self_attn', 'attn')}"
+
+        return f"transformer_text_model_encoder_layers_{m[0]}_{m[1]}"
+
+    return key
+
+
+class LoraOnDisk:
+    def __init__(self, name, filename):
+        self.name = name
+        self.filename = filename
+
+
+class LoraModule:
+    def __init__(self, name):
+        self.name = name
+        self.multiplier = 1.0
+        self.modules = {}
+        self.mtime = None
+
+
+class FakeModule(torch.nn.Module):
+    def __init__(self, weight, func):
+        super().__init__()
+        self.weight = weight
+        self.func = func
+    
+    def forward(self, x):
+        return self.func(x)
+
+
+class FullModule:
+    def __init__(self):
+        self.weight = None
+        self.alpha = None
+        self.op = None
+        self.extra_args = {}
+        self.shape = None
+        self.up = None
+    
+    def down(self, x):
+        return x
+    
+    def inference(self, x):
+        return self.op(x, self.weight, **self.extra_args)
+
+
+class LoraUpDownModule:
+    def __init__(self):
+        self.up_model = None
+        self.mid_model = None
+        self.down_model = None
+        self.alpha = None
+        self.dim = None
+        self.op = None
+        self.extra_args = {}
+        self.shape = None
+        self.bias = None
+        self.up = None
+    
+    def down(self, x):
+        return x
+    
+    def inference(self, x):
+        if hasattr(self, 'bias') and isinstance(self.bias, torch.Tensor):
+            out_dim = self.up_model.weight.size(0)
+            rank = self.down_model.weight.size(0)
+            rebuild_weight = (
+                self.up_model.weight.reshape(out_dim, -1) @ self.down_model.weight.reshape(rank, -1)
+                + self.bias
+            ).reshape(self.shape)
+            return self.op(
+                x, rebuild_weight,
+                bias=None,
+                **self.extra_args
+            )
+        else:
+            if self.mid_model is None:
+                return self.up_model(self.down_model(x))
+            else:
+                return self.up_model(self.mid_model(self.down_model(x)))
+
+
+def make_weight_cp(t, wa, wb):
+    temp = torch.einsum('i j k l, j r -> i r k l', t, wb)
+    return torch.einsum('i j k l, i r -> r j k l', temp, wa)
+
+
+class LoraHadaModule:
+    def __init__(self):
+        self.t1 = None
+        self.w1a = None
+        self.w1b = None
+        self.t2 = None
+        self.w2a = None
+        self.w2b = None
+        self.alpha = None
+        self.dim = None
+        self.op = None
+        self.extra_args = {}
+        self.shape = None
+        self.bias = None
+        self.up = None
+    
+    def down(self, x):
+        return x
+    
+    def inference(self, x):
+        if hasattr(self, 'bias') and isinstance(self.bias, torch.Tensor):
+            bias = self.bias
+        else:
+            bias = 0
+        
+        if self.t1 is None:
+            return self.op(
+                x,
+                ((self.w1a @ self.w1b) * (self.w2a @ self.w2b) + bias).view(self.shape),
+                bias=None,
+                **self.extra_args
+            )
+        else:
+            return self.op(
+                x,
+                (make_weight_cp(self.t1, self.w1a, self.w1b) 
+                 * make_weight_cp(self.t2, self.w2a, self.w2b) + bias).view(self.shape),
+                bias=None,
+                **self.extra_args
+            )
+
+
+class IA3Module:
+    def __init__(self):
+        self.w = None
+        self.alpha = None
+        self.on_input = None
+
+
+def make_kron(orig_shape, w1, w2):
+    if len(w2.shape) == 4:
+        w1 = w1.unsqueeze(2).unsqueeze(2)
+    w2 = w2.contiguous()
+    return torch.kron(w1, w2).reshape(orig_shape)
+
+
+class LoraKronModule:
+    def __init__(self):
+        self.w1 = None
+        self.w1a = None
+        self.w1b = None
+        self.w2 = None
+        self.t2 = None
+        self.w2a = None
+        self.w2b = None
+        self._alpha = None
+        self.dim = None
+        self.op = None
+        self.extra_args = {}
+        self.shape = None
+        self.bias = None
+        self.up = None
+    
+    @property
+    def alpha(self):
+        if self.w1a is None and self.w2a is None:
+            return None
+        else:
+            return self._alpha
+    
+    @alpha.setter
+    def alpha(self, x):
+        self._alpha = x
+    
+    def down(self, x):
+        return x
+    
+    def inference(self, x):
+        if hasattr(self, 'bias') and isinstance(self.bias, torch.Tensor):
+            bias = self.bias
+        else:
+            bias = 0
+        
+        if self.t2 is None:
+            return self.op(
+                x,
+                (torch.kron(self.w1, self.w2a@self.w2b) + bias).view(self.shape),
+                **self.extra_args
+            )
+        else:
+            # will raise NotImplemented Error
+            return self.op(
+                x,
+                (torch.kron(self.w1, make_weight_cp(self.t2, self.w2a, self.w2b)) + bias).view(self.shape),
+                **self.extra_args
+            )
+
+
+CON_KEY = {
+    "lora_up.weight",
+    "lora_down.weight",
+    "lora_mid.weight"
+}
+HADA_KEY = {
+    "hada_t1",
+    "hada_w1_a",
+    "hada_w1_b",
+    "hada_t2",
+    "hada_w2_a",
+    "hada_w2_b",
+}
+IA3_KEY = {
+    "weight",
+    "on_input"
+}
+KRON_KEY = {
+    "lokr_w1",
+    "lokr_w1_a",
+    "lokr_w1_b",
+    "lokr_t2",
+    "lokr_w2",
+    "lokr_w2_a",
+    "lokr_w2_b",
+}
+
+def load_lora(name, filename):
+    print('locon load lora method')
+    lora = LoraModule(name)
+    lora.mtime = os.path.getmtime(filename)
+
+    sd = sd_models.read_state_dict(filename)
+    is_sd2 = 'model_transformer_resblocks' in shared.sd_model.lora_layer_mapping
+
+    keys_failed_to_match = []
+
+    for key_diffusers, weight in sd.items():
+        fullkey = convert_diffusers_name_to_compvis(key_diffusers, is_sd2)
+        key, lora_key = fullkey.split(".", 1)
+        
+        sd_module = shared.sd_model.lora_layer_mapping.get(key, None)
+        
+        if sd_module is None:
+            m = re_x_proj.match(key)
+            if m:
+                sd_module = shared.sd_model.lora_layer_mapping.get(m.group(1), None)
+        
+        if sd_module is None:
+            print(key)
+            keys_failed_to_match.append(key_diffusers)
+            continue
+
+        lora_module = lora.modules.get(key, None)
+        if lora_module is None:
+            lora_module = LoraUpDownModule()
+            lora.modules[key] = lora_module
+
+        if lora_key == "alpha":
+            lora_module.alpha = weight.item()
+            continue
+        
+        if lora_key == "diff":
+            weight = weight.to(device=devices.device, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            lora_module = FullModule()
+            lora.modules[key] = lora_module
+            lora_module.weight = weight
+            lora_module.alpha = weight.size(1)
+            lora_module.up = FakeModule(
+                weight,
+                lora_module.inference
+            )
+            lora_module.up.to(device=devices.cpu if new_lora else devices.device, dtype=devices.dtype)
+            if len(weight.shape)==2:
+                lora_module.op = torch.nn.functional.linear
+                lora_module.extra_args = {
+                    'bias': None
+                }
+            else:
+                lora_module.op = torch.nn.functional.conv2d
+                lora_module.extra_args = {
+                    'stride': sd_module.stride,
+                    'padding': sd_module.padding,
+                    'bias': None
+                }
+            continue
+        
+        if 'bias_' in lora_key:
+            if lora_module.bias is None:
+                lora_module.bias = [None, None, None]
+            if 'bias_indices' == lora_key:
+                lora_module.bias[0] = weight
+            elif 'bias_values' == lora_key:
+                lora_module.bias[1] = weight
+            elif 'bias_size' == lora_key:
+                lora_module.bias[2] = weight
+            
+            if all((i is not None) for i in lora_module.bias):
+                print('build bias')
+                lora_module.bias = torch.sparse_coo_tensor(
+                    lora_module.bias[0],
+                    lora_module.bias[1],
+                    tuple(lora_module.bias[2]),
+                ).to(device=devices.cpu if new_lora else devices.device, dtype=devices.dtype)
+                lora_module.bias.requires_grad_(False)
+            continue
+        
+        if lora_key in CON_KEY:
+            if (type(sd_module) == torch.nn.Linear
+                or type(sd_module) == torch.nn.modules.linear.NonDynamicallyQuantizableLinear
+                or type(sd_module) == torch.nn.MultiheadAttention):
+                weight = weight.reshape(weight.shape[0], -1)
+                module = torch.nn.Linear(weight.shape[1], weight.shape[0], bias=False)
+                lora_module.op = torch.nn.functional.linear
+            elif type(sd_module) == torch.nn.Conv2d:
+                if lora_key == "lora_down.weight":
+                    if len(weight.shape) == 2:
+                        weight = weight.reshape(weight.shape[0], -1, 1, 1)
+                    if weight.shape[2] != 1 or weight.shape[3] != 1:
+                        module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], sd_module.kernel_size, sd_module.stride, sd_module.padding, bias=False)
+                    else:
+                        module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], (1, 1), bias=False)
+                elif lora_key == "lora_mid.weight":
+                    module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], sd_module.kernel_size, sd_module.stride, sd_module.padding, bias=False)
+                elif lora_key == "lora_up.weight":
+                    module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], (1, 1), bias=False)
+                lora_module.op = torch.nn.functional.conv2d
+                lora_module.extra_args = {
+                    'stride': sd_module.stride,
+                    'padding': sd_module.padding
+                }
+            else:
+                assert False, f'Lora layer {key_diffusers} matched a layer with unsupported type: {type(sd_module).__name__}'
+            
+            if hasattr(sd_module, 'weight'):
+                lora_module.shape = sd_module.weight.shape
+            with torch.no_grad():
+                if weight.shape != module.weight.shape:
+                    weight = weight.reshape(module.weight.shape)
+                module.weight.copy_(weight)
+
+            module.to(device=devices.cpu if new_lora else devices.device, dtype=devices.dtype)
+            module.requires_grad_(False)
+
+            if lora_key == "lora_up.weight":
+                lora_module.up_model = module
+                lora_module.up = FakeModule(
+                    lora_module.up_model.weight,
+                    lora_module.inference
+                )
+            elif lora_key == "lora_mid.weight":
+                lora_module.mid_model = module
+            elif lora_key == "lora_down.weight":
+                lora_module.down_model = module
+                lora_module.dim = weight.shape[0]
+            else:
+                print(lora_key)
+        elif lora_key in HADA_KEY:
+            if type(lora_module) != LoraHadaModule:
+                alpha = lora_module.alpha
+                bias = lora_module.bias
+                lora_module = LoraHadaModule()
+                lora_module.alpha = alpha
+                lora_module.bias = bias
+                lora.modules[key] = lora_module
+            if hasattr(sd_module, 'weight'):
+                lora_module.shape = sd_module.weight.shape
+            
+            weight = weight.to(device=devices.cpu if new_lora else devices.device, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            
+            if lora_key == 'hada_w1_a':
+                lora_module.w1a = weight
+                if lora_module.up is None:
+                    lora_module.up = FakeModule(
+                        lora_module.w1a,
+                        lora_module.inference
+                    )
+            elif lora_key == 'hada_w1_b':
+                lora_module.w1b = weight
+                lora_module.dim = weight.shape[0]
+            elif lora_key == 'hada_w2_a':
+                lora_module.w2a = weight
+            elif lora_key == 'hada_w2_b':
+                lora_module.w2b = weight
+            elif lora_key == 'hada_t1':
+                lora_module.t1 = weight
+                lora_module.up = FakeModule(
+                    lora_module.t1,
+                    lora_module.inference
+                )
+            elif lora_key == 'hada_t2':
+                lora_module.t2 = weight
+            
+            if (type(sd_module) == torch.nn.Linear
+                or type(sd_module) == torch.nn.modules.linear.NonDynamicallyQuantizableLinear
+                or type(sd_module) == torch.nn.MultiheadAttention):
+                lora_module.op = torch.nn.functional.linear
+            elif type(sd_module) == torch.nn.Conv2d:
+                lora_module.op = torch.nn.functional.conv2d
+                lora_module.extra_args = {
+                    'stride': sd_module.stride,
+                    'padding': sd_module.padding
+                }
+            else:
+                assert False, f'Lora layer {key_diffusers} matched a layer with unsupported type: {type(sd_module).__name__}'
+        elif lora_key in IA3_KEY:
+            if type(lora_module) != IA3Module:
+                lora_module = IA3Module()
+                lora.modules[key] = lora_module
+            
+            if lora_key == "weight":
+                lora_module.w = weight.to(devices.device, dtype=devices.dtype)
+            elif lora_key == "on_input":
+                lora_module.on_input = weight
+        elif lora_key in KRON_KEY:
+            if not isinstance(lora_module, LoraKronModule):
+                alpha = lora_module.alpha
+                bias = lora_module.bias
+                lora_module = LoraKronModule()
+                lora_module.alpha = alpha
+                lora_module.bias = bias
+                lora.modules[key] = lora_module
+            if hasattr(sd_module, 'weight'):
+                lora_module.shape = sd_module.weight.shape
+            
+            weight = weight.to(device=devices.cpu if new_lora else devices.device, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            
+            if lora_key == 'lokr_w1':
+                lora_module.w1 = weight
+            elif lora_key == 'lokr_w1_a':
+                lora_module.w1a = weight
+                if lora_module.up is None:
+                    lora_module.up = FakeModule(
+                        lora_module.w1a,
+                        lora_module.inference
+                    )
+            elif lora_key == 'lokr_w1_b':
+                lora_module.w1b = weight
+            elif lora_key == 'lokr_w2':
+                lora_module.w2 = weight
+            elif lora_key == 'lokr_w2_a':
+                lora_module.w2a = weight
+                lora_module.dim = weight.shape[0]
+                if lora_module.up is None:
+                    lora_module.up = FakeModule(
+                        lora_module.w2a,
+                        lora_module.inference
+                    )
+            elif lora_key == 'lokr_w2_b':
+                lora_module.w2b = weight
+            elif lora_key == 'lokr_t2':
+                lora_module.t2 = weight
+            
+            if (any(isinstance(sd_module, torch_layer) for torch_layer in 
+                    [torch.nn.Linear, torch.nn.modules.linear.NonDynamicallyQuantizableLinear, torch.nn.MultiheadAttention])):
+                lora_module.op = torch.nn.functional.linear
+            elif isinstance(sd_module, torch.nn.Conv2d):
+                lora_module.op = torch.nn.functional.conv2d
+                lora_module.extra_args = {
+                    'stride': sd_module.stride,
+                    'padding': sd_module.padding
+                }
+        else:
+            assert False, f'Bad Lora layer name: {key_diffusers} - must end in lora_up.weight, lora_down.weight or alpha'
+
+    if len(keys_failed_to_match) > 0:
+        print(shared.sd_model.lora_layer_mapping)
+        print(f"Failed to match keys when loading Lora {filename}: {keys_failed_to_match}")
+
+    return lora
+
+
+def lora_forward(module, input, res):
+    if len(lora.loaded_loras) == 0:
+        return res
+    
+    lora_layer_name = getattr(module, 'lora_layer_name', None)
+    for lora_m in lora.loaded_loras:
+        module = lora_m.modules.get(lora_layer_name, None)
+        if module is not None and lora_m.multiplier:
+            if hasattr(module, 'up'):
+                scale = lora_m.multiplier * (module.alpha / module.up.weight.size(1) if module.alpha else 1.0)
+            else:
+                scale = lora_m.multiplier * (module.alpha / module.dim if module.alpha else 1.0)
+            
+            if shared.opts.lora_apply_to_outputs and res.shape == input.shape:
+                x = res
+            else:
+                x = input
+            
+            if hasattr(module, 'inference'):
+                res = res + module.inference(x) * scale
+            elif hasattr(module, 'up'):
+                res = res + module.up(module.down(x)) * scale
+            else:
+                raise NotImplementedError(
+                    "Your settings, extensions or models are not compatible with each other."
+                )
+    return res
+
+
+def _rebuild_conventional(up, down, shape):
+    return (up.reshape(up.size(0), -1) @ down.reshape(down.size(0), -1)).reshape(shape)
+
+
+def _rebuild_cp_decomposition(up, down, mid):
+    up = up.reshape(up.size(0), -1)
+    down = down.reshape(down.size(0), -1)
+    return torch.einsum('n m k l, i n, m j -> i j k l', mid, up, down)
+
+
+def rebuild_weight(module, orig_weight: torch.Tensor) -> torch.Tensor:
+    if module.__class__.__name__ == 'LoraUpDownModule':
+        up = module.up_model.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+        down = module.down_model.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+        
+        output_shape = [up.size(0), down.size(1)]
+        if (mid:=module.mid_model) is not None:
+            # cp-decomposition
+            mid = mid.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown = _rebuild_cp_decomposition(up, down, mid)
+            output_shape += mid.shape[2:]
+        else:
+            if len(down.shape) == 4:
+                output_shape += down.shape[2:]
+            updown = _rebuild_conventional(up, down, output_shape)
+        
+    elif module.__class__.__name__ == 'LoraHadaModule':
+        w1a = module.w1a.to(orig_weight.device, dtype=orig_weight.dtype)
+        w1b = module.w1b.to(orig_weight.device, dtype=orig_weight.dtype)
+        w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+        w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+        
+        output_shape = [w1a.size(0), w1b.size(1)]
+        
+        if module.t1 is not None:
+            output_shape = [w1a.size(1), w1b.size(1)]
+            t1 = module.t1.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown1 = make_weight_cp(t1, w1a, w1b)
+            output_shape += t1.shape[2:]
+        else:
+            if len(w1b.shape) == 4:
+                output_shape += w1b.shape[2:]
+            updown1 = _rebuild_conventional(w1a, w1b, output_shape)
+        
+        if module.t2 is not None:
+            t2 = module.t2.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown2 = make_weight_cp(t2, w2a, w2b)
+        else:
+            updown2 = _rebuild_conventional(w2a, w2b, output_shape)
+        
+        updown = updown1 * updown2
+    
+    elif module.__class__.__name__ == 'FullModule':
+        output_shape = module.weight.shape
+        updown = module.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+    
+    elif module.__class__.__name__ == 'IA3Module':
+        output_shape = [module.w.size(0), orig_weight.size(1)]
+        if module.on_input:
+            output_shape.reverse()
+        else:
+            module.w = module.w.reshape(-1, 1)
+        updown = orig_weight * module.w
+        
+    elif module.__class__.__name__ == 'LoraKronModule':
+        if module.w1 is not None:
+            w1 = module.w1.to(orig_weight.device, dtype=orig_weight.dtype)
+        else:
+            w1a = module.w1a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w1b = module.w1b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w1 = w1a @ w1b
+        
+        if module.w2 is not None:
+            w2 = module.w2.to(orig_weight.device, dtype=orig_weight.dtype)
+        elif module.t2 is None:
+            w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2 = w2a @ w2b
+        else:
+            t2 = module.t2.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2 = make_weight_cp(t2, w2a, w2b)
+        
+        output_shape = [w1.size(0)*w2.size(0), w1.size(1)*w2.size(1)]
+        if len(orig_weight.shape) == 4:
+            output_shape = orig_weight.shape
+        
+        updown = make_kron(
+            output_shape, w1, w2
+        )
+    
+    else:
+        raise NotImplementedError(
+            f"Unknown module type: {module.__class__.__name__}\n"
+            "If the type is one of "
+            "'LoraUpDownModule', 'LoraHadaModule', 'FullModule', 'IA3Module', 'LoraKronModule'"
+            "You may have other lora extension that conflict with locon extension."
+        )
+    
+    if hasattr(module, 'bias') and module.bias != None:
+        updown = updown.reshape(module.bias.shape)
+        updown += module.bias.to(orig_weight.device, dtype=orig_weight.dtype)
+        updown = updown.reshape(output_shape)
+    
+    if len(output_shape) == 4:
+        updown = updown.reshape(output_shape)
+    
+    if orig_weight.size().numel() == updown.size().numel():
+        updown = updown.reshape(orig_weight.shape)
+    # print(torch.sum(updown))
+    return updown
+
+
+def lora_calc_updown(lora, module, target):
+    with torch.no_grad():
+        updown = rebuild_weight(module, target)
+        updown = updown * lora.multiplier * (module.alpha / module.up.weight.shape[1] if module.alpha else 1.0)
+        return updown
+
+
+lora.convert_diffusers_name_to_compvis = convert_diffusers_name_to_compvis
+lora.load_lora = load_lora
+lora.lora_forward = lora_forward
+lora.lora_calc_updown = lora_calc_updown
+print('LoCon Extension hijack built-in lora successfully')

a1111-microsoftexcel-tagcomplete/.gitignore

@@ -0,0 +1,2 @@
+tags/temp/
+__pycache__/

a1111-microsoftexcel-tagcomplete/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dominik Reh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

a1111-microsoftexcel-tagcomplete/README.md

@@ -0,0 +1,209 @@
+![tag_autocomplete_light](https://user-images.githubusercontent.com/34448969/208306863-90bbd663-2cb4-47f1-a7fe-7b662a7b95e2.png)
+
+# Booru tag autocompletion for A1111
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/DominikDoom/a1111-sd-webui-tagcomplete)](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)
+
+## [中文文档](./README_ZH.md)
+
+This custom script serves as a drop-in extension for the popular [AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) for Stable Diffusion.
+
+It displays autocompletion hints for recognized tags from "image booru" boards such as Danbooru, which are primarily used for browsing Anime-style illustrations.
+Since some Stable Diffusion models were trained using this information, for example [Waifu Diffusion](https://github.com/harubaru/waifu-diffusion), using exact tags in prompts can often improve composition and help to achieve a wanted look.
+
+You can install it using the inbuilt available extensions list, clone the files manually as described [below](#installation), or use a pre-packaged version from [Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases).
+
+## Common Problems & Known Issues:
+- Depending on your browser settings, sometimes an old version of the script can get cached. Try `CTRL+F5` to force-reload the site without cache if e.g. a new feature doesn't appear for you after an update.
+
+## Screenshots & Demo videos
+<details>
+<summary>Click to expand</summary>
+Basic usage (with keyboard navigation):
+
+https://user-images.githubusercontent.com/34448969/200128020-10d9a8b2-cea6-4e3f-bcd2-8c40c8c73233.mp4
+
+Wildcard script support:
+
+https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-ae36-5f6c8fd49df0.mp4
+
+Dark and Light mode supported, including tag colors:
+
+![results_dark](https://user-images.githubusercontent.com/34448969/200128214-3b6f21b4-9dda-4acf-820e-5df0285c30d6.png)
+![results_light](https://user-images.githubusercontent.com/34448969/200128217-bfac8b60-6673-447b-90fd-dc6326f1618c.png)
+</details>
+
+## Installation
+### Using the built-in extension list
+1. Open the Extensions tab
+2. Open the Available sub-tab
+3. Click "Load from:"
+4. Find "Booru tag autocompletion" in the list
+   - The extension was one of the first available, so selecting "oldest first" will show it high up in the list.
+5. Click "Install" on the right side
+
+![Load from index](https://user-images.githubusercontent.com/34448969/223537209-24c7623e-7410-427e-857f-9da936aadb21.png)
+![Order by oldest](https://user-images.githubusercontent.com/34448969/223537231-48e982b8-0920-48c5-87e5-8c81ebbb5fe3.png)
+![Install](https://user-images.githubusercontent.com/34448969/223537336-5c02ccb1-233d-4e0d-9e73-d1b889252c49.png)
+
+
+### Manual clone
+```bash
+git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extensions/tag-autocomplete
+```
+(The second argument specifies the name of the folder, you can choose whatever you like).
+
+## Additional completion support
+### Wildcards
+Autocompletion also works with wildcard files used by https://github.com/AUTOMATIC1111/stable-diffusion-webui-wildcards or other similar scripts/extensions.
+Completion is triggered by typing `__` (double underscore). It will first show a list of your wildcard files, and upon choosing one, the replacement options inside that file.
+This enables you to either insert categories to be replaced by the script, or directly choose one and use wildcards as a sort of categorized custom tag system.
+
+![Wildcard files](https://user-images.githubusercontent.com/34448969/223534518-8488c2e1-d9e5-4870-844f-adbf3bfb1eee.png)
+![Wildcard replacements](https://user-images.githubusercontent.com/34448969/223534534-69597907-59de-4ba8-ae83-b01386570124.png)
+
+
+Wildcards are searched for in every extension folder, as well as the `scripts/wildcards` folder to support legacy versions. This means that you can combine wildcards from multiple extensions. Nested folders are also supported if you have grouped your wildcards in that way.
+
+### Embeddings, Lora & Hypernets
+Completion for these three types is triggered by typing `<`. By default it will show all three mixed together, but further filtering can be done in the following way:
+- `<e:` will only show embeddings
+- `<l:` or `<lora:` will only show Lora
+- `<h:` or `<hypernet:` will only show Hypernetworks
+
+#### Embedding type filtering
+Embeddings trained for Stable Diffusion 1.x or 2.x models respectively are incompatible with the other type. To make it easier to find valid embeds, they are categorized by "v1 Embedding" and "v2 Embedding", including a slight color difference. You can also filter your search to include only v1 or v2 embeddings by typing `<v1/2` or `<e:v1/2` followed by the actual search term.
+
+For example:
+
+![Embedding version filter](https://user-images.githubusercontent.com/34448969/223533883-d99c04b7-a199-4f56-a4e5-242eee9726a2.png)
+
+### Umi AI tags
+https://github.com/Klokinator/Umi-AI is a feature-rich wildcard extension similar to Unprompted or Dynamic Wildcards.
+In recent releases, it uses YAML-based wildcard tags to enable a complex chaining system,for example `<[preset][--female][sfw][species]>` will choose the preset category, exclude female related tags, further narrow it down with the following categories, and then choose one random fill-in matching all these criteria at runtime. Completion is triggered by `<[` and then each following new unclosed bracket, e.g. `<[xyz][`, until closed by `>`.
+
+Tag Autocomplete can recommend these options in a smart way, meaning while you continue to add category tags, it will only show results still matching what comes before.
+It also shows how many fill-in tags are available to choose from for that combo in place of the tag post count, enabling a quick overview and filtering of the large initial set.
+
+Most of the credit goes to [@ctwrs](https://github.com/ctwrs) here, they contributed a lot as one of the Umi developers.
+
+## Settings
+
+The extension has a large amount of configuration & customizability built in:
+
+![image](https://user-images.githubusercontent.com/34448969/204093162-99c6a0e7-8183-4f47-963b-1f172774f527.png)
+
+| Setting	| Description |
+|---------|-------------|
+| tagFile | Specifies the tag file to use. You can provide a custom tag database of your liking, but since the script was developed with Danbooru tags in mind, it might not work properly with other configurations.|
+| activeIn | Allows to selectively (de)activate the script for txt2img, img2img, and the negative prompts for both. |
+| maxResults | How many results to show max. For the default tag set, the results are ordered by occurence count. For embeddings and wildcards it will show all results in a scrollable list. |
+| resultStepLength | Allows to load results in smaller batches of the specified size for better performance in long lists or if showAllResults is true. |
+| delayTime | Specifies how much to wait in milliseconds before triggering autocomplete. Helps prevent too frequent updates while typing. |
+| showAllResults | If true, will ignore maxResults and show all results in a scrollable list. **Warning:** can lag your browser for long lists. |
+| replaceUnderscores | If true, undescores are replaced with spaces on clicking a tag. Might work better for some models. |
+| escapeParentheses | If true, escapes tags containing () so they don't contribute to the web UI's prompt weighting functionality. |
+| appendComma | Specifies the starting value of the "Append commas" UI switch. If UI options are disabled, this will always be used. |
+| useWildcards | Used to toggle the wildcard completion functionality. |
+| useEmbeddings | Used to toggle the embedding completion functionality. |
+| alias | Options for aliases. More info in the section below. |
+| translation | Options for translations. More info in the section below.  |
+| extras | Options for additional tag files / aliases / translations. More info below. |
+| keymap | Customizable hotkeys. |
+| colors | Customizable tag colors. More info below. |
+### Colors
+Tag type colors can be specified by changing the JSON code in the tag autocomplete settings.
+The format is standard JSON, with the object names corresponding to the tag filenames (without the .csv) they should be used for.
+The first value in the square brackets is for dark, the second for light mode. Color names and hex codes should both work.
+```json
+{
+	"danbooru": {
+		"-1": ["red", "maroon"],
+		"0": ["lightblue", "dodgerblue"],
+		"1": ["indianred", "firebrick"],
+		"3": ["violet", "darkorchid"],
+		"4": ["lightgreen", "darkgreen"],
+		"5": ["orange", "darkorange"]
+	},
+	"e621": {
+		"-1": ["red", "maroon"],
+		"0": ["lightblue", "dodgerblue"],
+		"1": ["gold", "goldenrod"],
+		"3": ["violet", "darkorchid"],
+		"4": ["lightgreen", "darkgreen"],
+		"5": ["tomato", "darksalmon"],
+		"6": ["red", "maroon"],
+		"7": ["whitesmoke", "black"],
+		"8": ["seagreen", "darkseagreen"]
+	}
+}
+```
+This can also be used to add new color sets for custom tag files.
+The numbers are specifying the tag type, which is dependent on the tag source. For an example, see [CSV tag data](#csv-tag-data).
+
+### Aliases, Translations & Extra tags
+#### Aliases
+Like on Booru sites, tags can have one or multiple aliases which redirect to the actual value on completion. These will be searchable / shown according to the settings in `config.json`:
+- `searchByAlias` - Whether to also search for the alias or only the actual tag.
+- `onlyShowAlias` - Shows only the alias instead of `alias -> actual`. Only for displaying, the inserted text at the end is still the actual tag.
+
+#### Translations
+An additional file can be added in the translation section, which will be used to translate both tags and aliases and also enables searching by translation.
+This file needs to be a CSV in the format `<English tag/alias>,<Translation>`, but for backwards compatibility with older files that used a three column format, you can turn on `oldFormat` to use that instead.
+
+Example with chinese translation:
+
+![IME-input](https://user-images.githubusercontent.com/34448969/200126551-2264e9cc-abb2-4450-9afa-43f362a77ab0.png)
+![english-input](https://user-images.githubusercontent.com/34448969/200126513-bf6b3940-6e22-41b0-a369-f2b4640f87d6.png)
+
+#### Extra file
+An extra file can be used to add new / custom tags not included in the main set.
+The format is identical to the normal tag format shown in [CSV tag data](#csv-tag-data) below, with one exception:
+Since custom tags likely have no count, column three (or two if counting from zero) is instead used for the gray meta text displayed next to the tag.
+If left empty, it will instead show "Custom tag".
+
+An example with the included (very basic) extra-quality-tags.csv file:
+
+![image](https://user-images.githubusercontent.com/34448969/218264276-cd77ba8e-62d8-41a2-b03c-6c04887ee18b.png)
+
+Whether the custom tags should be added before or after the normal tags can be chosen in the settings.
+
+## CSV tag data
+The script expects a CSV file with tags saved in the following way:
+```csv
+<name>,<type>,<postCount>,"<aliases>"
+```
+Example:
+```csv
+1girl,0,4114588,"1girls,sole_female"
+solo,0,3426446,"female_solo,solo_female"
+highres,5,3008413,"high_res,high_resolution,hires"
+long_hair,0,2898315,longhair
+commentary_request,5,2610959,
+```
+Notably, it does not expect column names in the first row and both count and aliases are technically optional,
+although count is always included in the default data. Multiple aliases need to be comma separated as well, but encased in string quotes to not break the CSV parsing.
+
+The numbering system follows the [tag API docs](https://danbooru.donmai.us/wiki_pages/api%3Atags) of Danbooru:
+| Value	| Description |
+|-------|-------------|
+|0	| General     |
+|1	| Artist      |
+|3	| Copyright   |
+|4	| Character   |
+|5	| Meta        |
+
+or similarly for e621:
+| Value	| Description |
+|-------|-------------|
+|-1	| Invalid     |
+|0	| General     |
+|1	| Artist      |
+|3	| Copyright   |
+|4	| Character   |
+|5	| Species     |
+|6	| Invalid     |
+|7	| Meta        |
+|8	| Lore        |
+
+The tag type is used for coloring entries in the result list.

a1111-microsoftexcel-tagcomplete/README_ZH.md

@@ -0,0 +1,173 @@
+![tag_autocomplete_light_zh](https://user-images.githubusercontent.com/34448969/208307331-430696b4-e854-4458-b9e9-f6a6594f19e1.png)
+
+# Booru tag autocompletion for A1111
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/DominikDoom/a1111-sd-webui-tagcomplete)](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)
+## [English Document](./README.md)
+
+## 功能概述
+
+本脚本为 [AUTOMATIC1111 web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)的自定义脚本,能在输入Tag时提供booru风格（如Danbooru）的TAG自动补全。因为有一些模型是基于这种TAG风格训练的（例如[Waifu Diffusion](https://github.com/harubaru/waifu-diffusion)），因此使用这些Tag能获得较为精确的效果。
+
+这个脚本的创建是为了减少因复制Tag在Web UI和 booru网站的反复切换。
+你可以按照[以下方法](#installation)下载或拷贝文件，也可以使用[Releases](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/releases)中打包好的文件。
+
+## 常见问题 & 已知缺陷:
+- 当`replaceUnderscores`选项开启时, 脚本只会替换Tag的一部分如果Tag包含多个单词,比如将`atago (azur lane)`修改`atago`为`taihou`并使用自动补全时.会得到 `taihou (azur lane), lane)`的结果, 因为脚本没有把后面的部分认为成同一个Tag。
+
+## 演示与截图
+演示视频(使用了键盘导航):
+
+https://user-images.githubusercontent.com/34448969/200128020-10d9a8b2-cea6-4e3f-bcd2-8c40c8c73233.mp4
+
+Wildcard支持演示:
+
+https://user-images.githubusercontent.com/34448969/200128031-22dd7c33-71d1-464f-ae36-5f6c8fd49df0.mp4
+
+深浅色主题支持,包括Tag的颜色:
+
+![results_dark](https://user-images.githubusercontent.com/34448969/200128214-3b6f21b4-9dda-4acf-820e-5df0285c30d6.png)
+![results_light](https://user-images.githubusercontent.com/34448969/200128217-bfac8b60-6673-447b-90fd-dc6326f1618c.png)
+
+## 安装
+### 作为一种扩展（推荐）
+要么把它克隆到你的扩展文件夹里
+```bash
+git clone "https://github.com/DominikDoom/a1111-sd-webui-tagcomplete.git" extensions/tag-autocomplete
+```
+(第二个参数指定文件夹的名称，你可以选择任何你喜欢的东西）。
+
+或者手动创建一个文件夹，将 `javascript`、`scripts`和`tags`文件夹放在其中。
+
+### 在根目录下（过时的方法）
+这种安装方法适用于添加扩展系统之前的旧版webui，在目前的版本上是行不通的。
+
+---
+在这两种配置中，标签文件夹包含`colors.json`和脚本用于自动完成的标签数据。
+默认情况下，Tag数据包括`Danbooru.csv`和`e621.csv`。
+
+在扫描过`/embeddings`和wildcards后，会将列表存放在`tags/temp`文件夹下。删除该文件夹不会有任何影响，下次启动时它会重新创建。
+
+### 注意:
+本脚本的允许需要**全部的三个文件夹**。
+
+## [Wildcard](https://github.com/jtkelm2/stable-diffusion-webui-1/blob/master/scripts/wildcards.py) &  Embedding 支持
+自动补全同样适用于 [Wildcard](https://github.com/jtkelm2/stable-diffusion-webui-1/blob/master/scripts/wildcards.py)中所述的通配符文件(后面有演示视频)。这将使你能够插入Wildcard脚本需要的通配符，更进一步的，你还可以插入通配符文件内的某个具体Tag。
+
+当输入`__`字符时，`/scripts/wildcards`文件夹下的通配符文件会列出到自动补全，当你选择某个具体通配符文件时,会列出其中的所有的具体Tag,但如果你仅需要选择某个通配符，请按下空格。
+
+当输入`<`字符时，`embeddings`文件夹下的`.pt`和`.bin`文件会列出到自动完成。需要注意的是，一些颜文字也会包含`<`(比如`>_<`),所以它们也会出现在结果中。
+
+现在这项功能默认是启用的，并会自动扫描`/embeddings`和`/scripts/wildcards`文件夹，不再需要使用`tags/wildcardNames.txt`文件了，早期版本的用户可以将它删除。
+
+## 配置文件
+该扩展有大量的配置和可定制性的内建：
+
+![image](https://user-images.githubusercontent.com/34448969/204093162-99c6a0e7-8183-4f47-963b-1f172774f527.png)
+
+| 设置	| 描述 |
+|---------|-------------|
+| tagFile | 指定要使用的标记文件。您可以提供您喜欢的自定义标签数据库，但由于该脚本是在考虑 Danbooru 标签的情况下开发的，因此它可能无法与其他配置一起正常工作。|
+| activeIn | 允许有选择地（取消）激活 txt2img、img2img 和两者的否定提示的脚本。|
+| maxResults | 最多显示多少个结果。对于默认标记集，结果按出现次数排序。对于嵌入和通配符，它​​将在可滚动列表中显示所有结果。 |
+| showAllResults | 如果为真，将忽略 maxResults 并在可滚动列表中显示所有结果。 **警告：** 对于长列表，您的浏览器可能会滞后。 |
+| resultStepLength | 允许以指定大小的小批次加载结果，以便在长列表中获得更好的性能，或者在showAllResults为真时。 |
+| delayTime | 指定在触发自动完成之前要等待多少毫秒。有助于防止打字时过于频繁的更新。 |
+| replaceUnderscores | 如果为 true，则在单击标签时将取消划线替换为空格。对于某些型号可能会更好。|
+| escapeParentheses | 如果为 true，则转义包含 () 的标签，因此它们不会对 Web UI 的提示权重功能做出贡献。 |
+| useWildcards | 用于切换通配符完成功能。 |
+| useEmbeddings | 用于切换嵌入完成功能。 |
+| alias | 标签别名的选项。更多信息在下面的部分。 |
+| translation | 用于翻译标签的选项。更多信息在下面的部分。 |
+| extras | 附加标签文件/翻译的选项。更多信息在下面的部分。|
+
+### 标签颜色
+标签类型的颜色可以通过改变标签自动完成设置中的JSON代码来指定。格式是标准的JSON，对象名称对应于它们应该使用的标签文件名（没有.csv）
+
+方括号中的第一个值是指深色，第二个是指浅色模式。颜色名称和十六进制代码都应该有效。
+```json
+{
+	"danbooru": {
+		"-1": ["red", "maroon"],
+		"0": ["lightblue", "dodgerblue"],
+		"1": ["indianred", "firebrick"],
+		"3": ["violet", "darkorchid"],
+		"4": ["lightgreen", "darkgreen"],
+		"5": ["orange", "darkorange"]
+	},
+	"e621": {
+		"-1": ["red", "maroon"],
+		"0": ["lightblue", "dodgerblue"],
+		"1": ["gold", "goldenrod"],
+		"3": ["violet", "darkorchid"],
+		"4": ["lightgreen", "darkgreen"],
+		"5": ["tomato", "darksalmon"],
+		"6": ["red", "maroon"],
+		"7": ["whitesmoke", "black"],
+		"8": ["seagreen", "darkseagreen"]
+	}
+}
+```
+这也可以用来为自定义标签文件添加新的颜色集。数字是指定标签的类型，这取决于标签来源。关于例子，见[CSV tag data](#csv-tag-data)。
+
+### 别名，翻译&新增Tag
+#### 别名
+像Booru网站一样，标签可以有一个或多个别名，完成后重定向到实际值。这些将根据`config.json`中的设置进行搜索/显示。
+- `searchByAlias` - 是否也要搜索别名，或只搜索实际的标签。
+- `onlyShowAlias` - 只显示别名，不显示 `别名->实际`。仅用于显示，最后的文本仍然是实际的标签。
+
+#### 翻译
+可以在翻译部分添加一个额外的文件，它将被用来翻译标签和别名，同时也可以通过翻译进行搜索。
+这个文件需要是CSV格式的`<英语标签/别名>,<翻译>`，但为了向后兼容使用三栏格式的旧的额外文件，你可以打开`oldFormat`来代替它。
+
+完整和部分中文标签集的示例：
+
+![IME-input](https://user-images.githubusercontent.com/34448969/200126551-2264e9cc-abb2-4450-9afa-43f362a77ab0.png)
+![english-input](https://user-images.githubusercontent.com/34448969/200126513-bf6b3940-6e22-41b0-a369-f2b4640f87d6.png)
+
+#### Extra文件
+额外文件可以用来添加未包含在主集中的新的/自定义标签。
+其格式与下面 [CSV tag data](#csv-tag-data) 中的正常标签格式相同，但有一个例外。
+由于自定义标签没有帖子计数，第三列（如果从零开始计算，则为第二列）用于显示标签旁边的灰色元文本。
+如果留空，它将显示 "Custom tag"。
+
+以默认的（非常基本的）extra-quality-tags.csv为例：
+
+![image](https://user-images.githubusercontent.com/34448969/218264276-cd77ba8e-62d8-41a2-b03c-6c04887ee18b.png)
+
+你可以在设置中选择自定义标签是否应该加在常规标签之前或之后。
+
+### CSV tag data
+本脚本的Tag文件格式如下，你可以安装这个格式制作自己的Tag文件：
+```csv
+1girl,0,4114588,"1girls,sole_female"
+solo,0,3426446,"female_solo,solo_female"
+highres,5,3008413,"high_res,high_resolution,hires"
+long_hair,0,2898315,longhair
+commentary_request,5,2610959,
+```
+值得注意的是，不希望在第一行有列名，而且count和aliases在技术上都是可选的。
+尽管count总是包含在默认数据中。多个别名也需要用逗号分隔，但要用字符串引号包裹，以免破坏CSV解析。
+编号系统遵循 Danbooru 的 [tag API docs](https://danbooru.donmai.us/wiki_pages/api%3Atags)：
+| Value	| Description |
+|-------|-------------|
+|0	    | General     |
+|1	    | Artist      |
+|3	    | Copyright   |
+|4	    | Character   |
+|5	    | Meta        |
+
+类似的还有e621：
+| Value	| Description |
+|-------|-------------|
+|-1	    | Invalid     |
+|0	    | General     |
+|1	    | Artist      |
+|3	    | Copyright   |
+|4	    | Character   |
+|5	    | Species     |
+|6	    | Invalid     |
+|7	    | Meta        |
+|8	    | Lore        |
+
+标记类型用于为结果列表中的条目着色.

a1111-microsoftexcel-tagcomplete/javascript/__globals.js

@@ -0,0 +1,52 @@
+// Core components
+var CFG = null;
+var tagBasePath = "";
+
+// Tag completion data loaded from files
+var allTags = [];
+var translations = new Map();
+var extras = [];
+// Same for tag-likes
+var wildcardFiles = [];
+var wildcardExtFiles = [];
+var yamlWildcards = [];
+var embeddings = [];
+var hypernetworks = [];
+var loras = [];
+var lycos = [];
+
+// Selected model info for black/whitelisting
+var currentModelHash = "";
+var currentModelName = "";
+
+// Current results
+var results = [];
+var resultCount = 0;
+
+// Relevant for parsing
+var previousTags = [];
+var tagword = "";
+var originalTagword = "";
+let hideBlocked = false;
+
+// Tag selection for keyboard navigation
+var selectedTag = null;
+var oldSelectedTag = null;
+
+// UMI
+var umiPreviousTags = [];
+
+/// Extendability system:
+/// Provides "queues" for other files of the script (or really any js)
+/// to add functions to be called at certain points in the script.
+/// Similar to a callback system, but primitive.
+
+// Queues
+const QUEUE_AFTER_INSERT = [];
+const QUEUE_AFTER_SETUP = [];
+const QUEUE_FILE_LOAD = [];
+const QUEUE_AFTER_CONFIG_CHANGE = [];
+const QUEUE_SANITIZE = [];
+
+// List of parsers to try
+const PARSERS = [];

a1111-microsoftexcel-tagcomplete/javascript/_baseParser.js

@@ -0,0 +1,21 @@
+class FunctionNotOverriddenError extends Error {
+    constructor(message = "", ...args) {
+        super(message, ...args);
+        this.message = message + " is an abstract base function and must be overwritten.";
+      }
+}
+
+class BaseTagParser {
+    triggerCondition = null;
+
+    constructor (triggerCondition) {
+        if (new.target === BaseTagParser) {
+            throw new TypeError("Cannot construct abstract BaseCompletionParser directly");
+        }
+        this.triggerCondition = triggerCondition;
+    }
+
+    parse() {
+        throw new FunctionNotOverriddenError("parse()");
+    }
+}

a1111-microsoftexcel-tagcomplete/javascript/_caretPosition.js

@@ -0,0 +1,145 @@
+// From https://github.com/component/textarea-caret-position
+
+// We'll copy the properties below into the mirror div.
+// Note that some browsers, such as Firefox, do not concatenate properties
+// into their shorthand (e.g. padding-top, padding-bottom etc. -> padding),
+// so we have to list every single property explicitly.
+var properties = [
+  'direction',  // RTL support
+  'boxSizing',
+  'width',  // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
+  'height',
+  'overflowX',
+  'overflowY',  // copy the scrollbar for IE
+
+  'borderTopWidth',
+  'borderRightWidth',
+  'borderBottomWidth',
+  'borderLeftWidth',
+  'borderStyle',
+
+  'paddingTop',
+  'paddingRight',
+  'paddingBottom',
+  'paddingLeft',
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/font
+  'fontStyle',
+  'fontVariant',
+  'fontWeight',
+  'fontStretch',
+  'fontSize',
+  'fontSizeAdjust',
+  'lineHeight',
+  'fontFamily',
+
+  'textAlign',
+  'textTransform',
+  'textIndent',
+  'textDecoration',  // might not make a difference, but better be safe
+
+  'letterSpacing',
+  'wordSpacing',
+
+  'tabSize',
+  'MozTabSize'
+
+];
+
+var isBrowser = (typeof window !== 'undefined');
+var isFirefox = (isBrowser && window.mozInnerScreenX != null);
+
+function getCaretCoordinates(element, position, options) {
+  if (!isBrowser) {
+    throw new Error('textarea-caret-position#getCaretCoordinates should only be called in a browser');
+  }
+
+  var debug = options && options.debug || false;
+  if (debug) {
+    var el = document.querySelector('#input-textarea-caret-position-mirror-div');
+    if (el) el.parentNode.removeChild(el);
+  }
+
+  // The mirror div will replicate the textarea's style
+  var div = document.createElement('div');
+  div.id = 'input-textarea-caret-position-mirror-div';
+  document.body.appendChild(div);
+
+  var style = div.style;
+  var computed = window.getComputedStyle ? window.getComputedStyle(element) : element.currentStyle;  // currentStyle for IE < 9
+  var isInput = element.nodeName === 'INPUT';
+
+  // Default textarea styles
+  style.whiteSpace = 'pre-wrap';
+  if (!isInput)
+    style.wordWrap = 'break-word';  // only for textarea-s
+
+  // Position off-screen
+  style.position = 'absolute';  // required to return coordinates properly
+  if (!debug)
+    style.visibility = 'hidden';  // not 'display: none' because we want rendering
+
+  // Transfer the element's properties to the div
+  properties.forEach(function (prop) {
+    if (isInput && prop === 'lineHeight') {
+      // Special case for <input>s because text is rendered centered and line height may be != height
+      if (computed.boxSizing === "border-box") {
+        var height = parseInt(computed.height);
+        var outerHeight =
+          parseInt(computed.paddingTop) +
+          parseInt(computed.paddingBottom) +
+          parseInt(computed.borderTopWidth) +
+          parseInt(computed.borderBottomWidth);
+        var targetHeight = outerHeight + parseInt(computed.lineHeight);
+        if (height > targetHeight) {
+          style.lineHeight = height - outerHeight + "px";
+        } else if (height === targetHeight) {
+          style.lineHeight = computed.lineHeight;
+        } else {
+          style.lineHeight = 0;
+        }
+      } else {
+        style.lineHeight = computed.height;
+      }
+    } else {
+      style[prop] = computed[prop];
+    }
+  });
+
+  if (isFirefox) {
+    // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
+    if (element.scrollHeight > parseInt(computed.height))
+      style.overflowY = 'scroll';
+  } else {
+    style.overflow = 'hidden';  // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
+  }
+
+  div.textContent = element.value.substring(0, position);
+  // The second special handling for input type="text" vs textarea:
+  // spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
+  if (isInput)
+    div.textContent = div.textContent.replace(/\s/g, '\u00a0');
+
+  var span = document.createElement('span');
+  // Wrapping must be replicated *exactly*, including when a long word gets
+  // onto the next line, with whitespace at the end of the line before (#7).
+  // The  *only* reliable way to do that is to copy the *entire* rest of the
+  // textarea's content into the <span> created at the caret position.
+  // For inputs, just '.' would be enough, but no need to bother.
+  span.textContent = element.value.substring(position) || '.';  // || because a completely empty faux span doesn't render at all
+  div.appendChild(span);
+
+  var coordinates = {
+    top: span.offsetTop + parseInt(computed['borderTopWidth']),
+    left: span.offsetLeft + parseInt(computed['borderLeftWidth']),
+    height: parseInt(computed['lineHeight'])
+  };
+
+  if (debug) {
+    span.style.backgroundColor = '#aaa';
+  } else {
+    document.body.removeChild(div);
+  }
+
+  return coordinates;
+}

a1111-microsoftexcel-tagcomplete/javascript/_result.js

@@ -0,0 +1,33 @@
+// Result data type for cleaner use of optional completion result properties
+
+// Type enum
+const ResultType = Object.freeze({
+    "tag": 1,
+    "extra": 2,
+    "embedding": 3,
+    "wildcardTag": 4,
+    "wildcardFile": 5,
+    "yamlWildcard": 6,
+    "hypernetwork": 7,
+    "lora": 8,
+    "lyco": 9
+});
+
+// Class to hold result data and annotations to make it clearer to use
+class AutocompleteResult {
+    // Main properties
+    text = "";
+    type = ResultType.tag;
+
+    // Additional info, only used in some cases
+    category = null;
+    count = null;
+    aliases = null;
+    meta = null;
+
+    // Constructor
+    constructor(text, type) {
+        this.text = text;
+        this.type = type;
+    }
+}

a1111-microsoftexcel-tagcomplete/javascript/_textAreas.js

@@ -0,0 +1,167 @@
+// Utility functions to select text areas the script should work on,
+// including third party options.
+// Supported third party options so far:
+// - Dataset Tag Editor
+
+// Core text area selectors
+const core = [
+    "#txt2img_prompt > label > textarea",
+    "#img2img_prompt > label > textarea",
+    "#txt2img_neg_prompt > label > textarea",
+    "#img2img_neg_prompt > label > textarea"
+];
+
+// Third party text area selectors
+const thirdParty = {
+    "dataset-tag-editor": {
+        "base": "#tab_dataset_tag_editor_interface",
+        "hasIds": false,
+        "selectors": [
+            "Caption of Selected Image",
+            "Interrogate Result",
+            "Edit Caption",
+            "Edit Tags"
+        ]
+    },
+    "image browser": {
+        "base": "#tab_image_browser",
+        "hasIds": false,
+        "selectors": [
+            "Filename keyword search",
+            "EXIF keyword search"
+        ]
+    },
+    "tab_tagger": {
+        "base": "#tab_tagger",
+        "hasIds": false,
+        "selectors": [
+            "Additional tags (split by comma)",
+            "Exclude tags (split by comma)"
+        ]
+    },
+    "tiled-diffusion-t2i": {
+        "base": "#txt2img_script_container",
+        "hasIds": true,
+        "onDemand": true,
+        "selectors": [
+            "[id^=MD-t2i][id$=prompt] textarea",
+            "[id^=MD-t2i][id$=prompt] input[type='text']"
+        ]
+    },
+    "tiled-diffusion-i2i": {
+        "base": "#img2img_script_container",
+        "hasIds": true,
+        "onDemand": true,
+        "selectors": [
+            "[id^=MD-i2i][id$=prompt] textarea",
+            "[id^=MD-i2i][id$=prompt] input[type='text']"
+        ]
+    }
+}
+
+function getTextAreas() {
+    // First get all core text areas
+    let textAreas = [...gradioApp().querySelectorAll(core.join(", "))];
+
+    for (const [key, entry] of Object.entries(thirdParty)) {
+        if (entry.hasIds) { // If the entry has proper ids, we can just select them
+            textAreas = textAreas.concat([...gradioApp().querySelectorAll(entry.selectors.join(", "))]);
+        } else { // Otherwise, we have to find the text areas by their adjacent labels
+            let base = gradioApp().querySelector(entry.base);
+
+            // Safety check
+            if (!base) continue;
+
+            let allTextAreas = [...base.querySelectorAll("textarea, input[type='text']")];
+
+            // Filter the text areas where the adjacent label matches one of the selectors
+            let matchingTextAreas = allTextAreas.filter(ta => [...ta.parentElement.childNodes].some(x => entry.selectors.includes(x.innerText)));
+            textAreas = textAreas.concat(matchingTextAreas);
+        }
+    };
+
+    return textAreas;
+}
+
+function addOnDemandObservers(setupFunction) {
+    for (const [key, entry] of Object.entries(thirdParty)) {
+        if (!entry.onDemand) continue;
+
+        let base = gradioApp().querySelector(entry.base);
+        if (!base) continue;
+        
+        let accordions = [...base?.querySelectorAll(".gradio-accordion")];
+        if (!accordions) continue;
+
+        accordions.forEach(acc => {
+            let accObserver = new MutationObserver((mutationList, observer) => {
+                for (const mutation of mutationList) {
+                    if (mutation.type === "childList") {
+                        let newChildren = mutation.addedNodes;
+                        if (!newChildren) {
+                            accObserver.disconnect();
+                            continue;
+                        }
+
+                        newChildren.forEach(child => {
+                            if (child.classList.contains("gradio-accordion") || child.querySelector(".gradio-accordion")) {
+                                let newAccordions = [...child.querySelectorAll(".gradio-accordion")];
+                                newAccordions.forEach(nAcc => accObserver.observe(nAcc, { childList: true }));
+                            }
+                        });
+
+                        if (entry.hasIds) { // If the entry has proper ids, we can just select them
+                            [...gradioApp().querySelectorAll(entry.selectors.join(", "))].forEach(x => setupFunction(x));
+                        } else { // Otherwise, we have to find the text areas by their adjacent labels
+                            let base = gradioApp().querySelector(entry.base);
+                
+                            // Safety check
+                            if (!base) continue;
+                
+                            let allTextAreas = [...base.querySelectorAll("textarea, input[type='text']")];
+                
+                            // Filter the text areas where the adjacent label matches one of the selectors
+                            let matchingTextAreas = allTextAreas.filter(ta => [...ta.parentElement.childNodes].some(x => entry.selectors.includes(x.innerText)));
+                            matchingTextAreas.forEach(x => setupFunction(x));
+                        }
+                    }
+                }
+            });
+            accObserver.observe(acc, { childList: true });
+        });
+    };
+}
+
+const thirdPartyIdSet = new Set();
+// Get the identifier for the text area to differentiate between positive and negative
+function getTextAreaIdentifier(textArea) {
+    let txt2img_p = gradioApp().querySelector('#txt2img_prompt > label > textarea');
+    let txt2img_n = gradioApp().querySelector('#txt2img_neg_prompt > label > textarea');
+    let img2img_p = gradioApp().querySelector('#img2img_prompt > label > textarea');
+    let img2img_n = gradioApp().querySelector('#img2img_neg_prompt > label > textarea');
+
+    let modifier = "";
+    switch (textArea) {
+        case txt2img_p:
+            modifier = ".txt2img.p";
+            break;
+        case txt2img_n:
+            modifier = ".txt2img.n";
+            break;
+        case img2img_p:
+            modifier = ".img2img.p";
+            break;
+        case img2img_n:
+            modifier = ".img2img.n";
+            break;
+        default:
+            // If the text area is not a core text area, it must be a third party text area
+            // Add it to the set of third party text areas and get its index as a unique identifier
+            if (!thirdPartyIdSet.has(textArea))
+                thirdPartyIdSet.add(textArea);
+
+            modifier = `.thirdParty.ta${[...thirdPartyIdSet].indexOf(textArea)}`;
+            break;
+    }
+    return modifier;
+}

a1111-microsoftexcel-tagcomplete/javascript/_utils.js

@@ -0,0 +1,130 @@
+// Utility functions for tag autocomplete
+
+// Parse the CSV file into a 2D array. Doesn't use regex, so it is very lightweight.
+function parseCSV(str) {
+    var arr = [];
+    var quote = false;  // 'true' means we're inside a quoted field
+
+    // Iterate over each character, keep track of current row and column (of the returned array)
+    for (var row = 0, col = 0, c = 0; c < str.length; c++) {
+        var cc = str[c], nc = str[c + 1];        // Current character, next character
+        arr[row] = arr[row] || [];             // Create a new row if necessary
+        arr[row][col] = arr[row][col] || '';   // Create a new column (start with empty string) if necessary
+
+        // If the current character is a quotation mark, and we're inside a
+        // quoted field, and the next character is also a quotation mark,
+        // add a quotation mark to the current column and skip the next character
+        if (cc == '"' && quote && nc == '"') { arr[row][col] += cc; ++c; continue; }
+
+        // If it's just one quotation mark, begin/end quoted field
+        if (cc == '"') { quote = !quote; continue; }
+
+        // If it's a comma and we're not in a quoted field, move on to the next column
+        if (cc == ',' && !quote) { ++col; continue; }
+
+        // If it's a newline (CRLF) and we're not in a quoted field, skip the next character
+        // and move on to the next row and move to column 0 of that new row
+        if (cc == '\r' && nc == '\n' && !quote) { ++row; col = 0; ++c; continue; }
+
+        // If it's a newline (LF or CR) and we're not in a quoted field,
+        // move on to the next row and move to column 0 of that new row
+        if (cc == '\n' && !quote) { ++row; col = 0; continue; }
+        if (cc == '\r' && !quote) { ++row; col = 0; continue; }
+
+        // Otherwise, append the current character to the current column
+        arr[row][col] += cc;
+    }
+    return arr;
+}
+
+// Load file
+async function readFile(filePath, json = false, cache = false) {
+    if (!cache)
+        filePath += `?${new Date().getTime()}`;
+        
+    let response = await fetch(`file=${filePath}`);
+
+    if (response.status != 200) {
+        console.error(`Error loading file "${filePath}": ` + response.status, response.statusText);
+        return null;
+    }
+
+    if (json)
+        return await response.json();
+    else
+        return await response.text();
+}
+
+// Load CSV
+async function loadCSV(path) {
+    let text = await readFile(path);
+    return parseCSV(text);
+}
+
+// Debounce function to prevent spamming the autocomplete function
+var dbTimeOut;
+const debounce = (func, wait = 300) => {
+    return function (...args) {
+        if (dbTimeOut) {
+            clearTimeout(dbTimeOut);
+        }
+
+        dbTimeOut = setTimeout(() => {
+            func.apply(this, args);
+        }, wait);
+    }
+}
+
+// Difference function to fix duplicates not being seen as changes in normal filter
+function difference(a, b) {
+    if (a.length == 0) {
+        return b;
+    }
+    if (b.length == 0) {
+        return a;
+    }
+
+    return [...b.reduce((acc, v) => acc.set(v, (acc.get(v) || 0) - 1),
+        a.reduce((acc, v) => acc.set(v, (acc.get(v) || 0) + 1), new Map())
+    )].reduce((acc, [v, count]) => acc.concat(Array(Math.abs(count)).fill(v)), []);
+}
+
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+function escapeHTML(unsafeText) {
+    let div = document.createElement('div');
+    div.textContent = unsafeText;
+    return div.innerHTML;
+}
+
+// Queue calling function to process global queues
+async function processQueue(queue, context, ...args) {
+    for (let i = 0; i < queue.length; i++) {
+        await queue[i].call(context, ...args);
+    }
+}
+// The same but with return values
+async function processQueueReturn(queue, context, ...args)
+{
+    let qeueueReturns = [];
+    for (let i = 0; i < queue.length; i++) {
+        let returnValue = await queue[i].call(context, ...args);
+        if (returnValue)
+            qeueueReturns.push(returnValue);
+    }
+    return qeueueReturns;
+}
+// Specific to tag completion parsers
+async function processParsers(textArea, prompt) {
+    // Get all parsers that have a successful trigger condition
+    let matchingParsers = PARSERS.filter(parser => parser.triggerCondition());
+    // Guard condition
+    if (matchingParsers.length === 0) {
+        return null;
+    }
+
+    let parseFunctions = matchingParsers.map(parser => parser.parse);
+    // Process them and return the results
+    return await processQueueReturn(parseFunctions, null, textArea, prompt);
+}

a1111-microsoftexcel-tagcomplete/javascript/ext_embeddings.js

@@ -0,0 +1,61 @@
+const EMB_REGEX = /<(?!l:|h:)[^,> ]*>?/g;
+const EMB_TRIGGER = () => CFG.useEmbeddings && tagword.match(EMB_REGEX);
+
+class EmbeddingParser extends BaseTagParser {
+    parse() {
+        // Show embeddings
+        let tempResults = [];
+        if (tagword !== "<" && tagword !== "<e:") {
+            let searchTerm = tagword.replace("<e:", "").replace("<", "");
+            let versionString;
+            if (searchTerm.startsWith("v1") || searchTerm.startsWith("v2")) {
+                versionString = searchTerm.slice(0, 2);
+                searchTerm = searchTerm.slice(2);
+            }
+
+            let filterCondition = x => x[0].toLowerCase().includes(searchTerm) || x[0].toLowerCase().replaceAll(" ", "_").includes(searchTerm);
+
+            if (versionString)
+                tempResults = embeddings.filter(x => filterCondition(x) && x[1] && x[1] === versionString); // Filter by tagword
+            else
+                tempResults = embeddings.filter(x => filterCondition(x)); // Filter by tagword
+        } else {
+            tempResults = embeddings;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t[0].trim(), ResultType.embedding)
+            result.meta = t[1] + " Embedding";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+async function load() {
+    if (embeddings.length === 0) {
+        try {
+            embeddings = (await readFile(`${tagBasePath}/temp/emb.txt`)).split("\n")
+                .filter(x => x.trim().length > 0) // Remove empty lines
+                .map(x => x.trim().split(",")); // Split into name, version type pairs
+        } catch (e) {
+            console.error("Error loading embeddings.txt: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.embedding) {
+        return text.replace(/^.*?: /g, "");
+    }
+    return null;
+}
+
+PARSERS.push(new EmbeddingParser(EMB_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-microsoftexcel-tagcomplete/javascript/ext_hypernets.js

@@ -0,0 +1,51 @@
+const HYP_REGEX = /<(?!e:|l:)[^,> ]*>?/g;
+const HYP_TRIGGER = () => CFG.useHypernetworks && tagword.match(HYP_REGEX);
+
+class HypernetParser extends BaseTagParser {
+    parse() {
+        // Show hypernetworks
+        let tempResults = [];
+        if (tagword !== "<" && tagword !== "<h:" && tagword !== "<hypernet:") {
+            let searchTerm = tagword.replace("<hypernet:", "").replace("<h:", "").replace("<", "");
+            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
+            tempResults = hypernetworks.filter(x => filterCondition(x)); // Filter by tagword
+        } else {
+            tempResults = hypernetworks;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.hypernetwork)
+            result.meta = "Hypernetwork";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+async function load() {
+    if (hypernetworks.length === 0) {
+        try {
+            hypernetworks = (await readFile(`${tagBasePath}/temp/hyp.txt`)).split("\n")
+                .filter(x => x.trim().length > 0) //Remove empty lines
+                .map(x => x.trim()); // Remove carriage returns and padding if it exists
+        } catch (e) {
+            console.error("Error loading hypernetworks.txt: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.hypernetwork) {
+        return `<hypernet:${text}:${CFG.extraNetworksDefaultMultiplier}>`;
+    }
+    return null;
+}
+
+PARSERS.push(new HypernetParser(HYP_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-microsoftexcel-tagcomplete/javascript/ext_loras.js

@@ -0,0 +1,51 @@
+const LORA_REGEX = /<(?!e:|h:)[^,> ]*>?/g;
+const LORA_TRIGGER = () => CFG.useLoras && tagword.match(LORA_REGEX);
+
+class LoraParser extends BaseTagParser {
+    parse() {
+        // Show lora
+        let tempResults = [];
+        if (tagword !== "<" && tagword !== "<l:" && tagword !== "<lora:") {
+            let searchTerm = tagword.replace("<lora:", "").replace("<l:", "").replace("<", "");
+            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
+            tempResults = loras.filter(x => filterCondition(x)); // Filter by tagword
+        } else {
+            tempResults = loras;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.lora)
+            result.meta = "Lora";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+async function load() {
+    if (loras.length === 0) {
+        try {
+            loras = (await readFile(`${tagBasePath}/temp/lora.txt`)).split("\n")
+                .filter(x => x.trim().length > 0) // Remove empty lines
+                .map(x => x.trim()); // Remove carriage returns and padding if it exists
+        } catch (e) {
+            console.error("Error loading lora.txt: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.lora) {
+        return `<lora:${text}:${CFG.extraNetworksDefaultMultiplier}>`;
+    }
+    return null;
+}
+
+PARSERS.push(new LoraParser(LORA_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-microsoftexcel-tagcomplete/javascript/ext_lycos.js

@@ -0,0 +1,51 @@
+const LYCO_REGEX = /<(?!e:|h:)[^,> ]*>?/g;
+const LYCO_TRIGGER = () => CFG.useLycos && tagword.match(LYCO_REGEX);
+
+class LycoParser extends BaseTagParser {
+    parse() {
+        // Show lyco
+        let tempResults = [];
+        if (tagword !== "<" && tagword !== "<l:" && tagword !== "<lyco:") {
+            let searchTerm = tagword.replace("<lyco:", "").replace("<l:", "").replace("<", "");
+            let filterCondition = x => x.toLowerCase().includes(searchTerm) || x.toLowerCase().replaceAll(" ", "_").includes(searchTerm);
+            tempResults = lycos.filter(x => filterCondition(x)); // Filter by tagword
+        } else {
+            tempResults = lycos;
+        }
+
+        // Add final results
+        let finalResults = [];
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.lyco)
+            result.meta = "Lyco";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+async function load() {
+    if (lycos.length === 0) {
+        try {
+            lycos = (await readFile(`${tagBasePath}/temp/lyco.txt`)).split("\n")
+                .filter(x => x.trim().length > 0) // Remove empty lines
+                .map(x => x.trim()); // Remove carriage returns and padding if it exists
+        } catch (e) {
+            console.error("Error loading lyco.txt: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.lyco) {
+        return `<lyco:${text}:${CFG.extraNetworksDefaultMultiplier}>`;
+    }
+    return null;
+}
+
+PARSERS.push(new LycoParser(LYCO_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);

a1111-microsoftexcel-tagcomplete/javascript/ext_umi.js

@@ -0,0 +1,240 @@
+const UMI_PROMPT_REGEX = /<[^\s]*?\[[^,<>]*[\]|]?>?/gi;
+const UMI_TAG_REGEX = /(?:\[|\||--)([^<>\[\]\-|]+)/gi;
+
+const UMI_TRIGGER = () => CFG.useWildcards && [...tagword.matchAll(UMI_PROMPT_REGEX)].length > 0;
+
+class UmiParser extends BaseTagParser {
+    parse(textArea, prompt) {
+        // We are in a UMI yaml tag definition, parse further
+        let umiSubPrompts = [...prompt.matchAll(UMI_PROMPT_REGEX)];
+                
+        let umiTags = [];
+        let umiTagsWithOperators = []
+
+        const insertAt = (str,char,pos) => str.slice(0,pos) + char + str.slice(pos);
+
+        umiSubPrompts.forEach(umiSubPrompt => {
+            umiTags = umiTags.concat([...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map(x => x[1].toLowerCase()));
+            
+            const start = umiSubPrompt.index;
+            const end = umiSubPrompt.index + umiSubPrompt[0].length;
+            if (textArea.selectionStart >= start && textArea.selectionStart <= end) {
+                umiTagsWithOperators = insertAt(umiSubPrompt[0], '###', textArea.selectionStart - start);
+            }
+        });
+
+        // Safety check since UMI parsing sometimes seems to trigger outside of an UMI subprompt and thus fails
+        if (umiTagsWithOperators.length === 0) {
+            return null;
+        }
+
+        const promptSplitToTags = umiTagsWithOperators.replace(']###[', '][').split("][");
+
+        const clean = (str) => str
+            .replaceAll('>', '')
+            .replaceAll('<', '')
+            .replaceAll('[', '')
+            .replaceAll(']', '')
+            .trim();
+
+        const matches = promptSplitToTags.reduce((acc, curr) => {
+            let isOptional = curr.includes("|");
+            let isNegative = curr.startsWith("--");
+            let out;
+            if (isOptional) {
+                out = {
+                    hasCursor: curr.includes("###"),
+                    tags: clean(curr).split('|').map(x => ({ 
+                        hasCursor: x.includes("###"), 
+                        isNegative: x.startsWith("--"),
+                        tag: clean(x).replaceAll("###", '').replaceAll("--", '')
+                    }))
+                };
+                acc.optional.push(out);
+                acc.all.push(...out.tags.map(x => x.tag));
+            } else if (isNegative) {
+                out = {
+                    hasCursor: curr.includes("###"),
+                    tags: clean(curr).replaceAll("###", '').split('|'),
+                };
+                out.tags = out.tags.map(x => x.startsWith("--") ? x.substring(2) : x);
+                acc.negative.push(out);
+                acc.all.push(...out.tags);
+            } else {
+                out = {
+                    hasCursor: curr.includes("###"),
+                    tags: clean(curr).replaceAll("###", '').split('|'),
+                };
+                acc.positive.push(out);
+                acc.all.push(...out.tags);
+            }
+            return acc;
+        }, { positive: [], negative: [], optional: [], all: [] });
+
+        //console.log({ matches })
+
+        const filteredWildcards = (tagword) => {
+            const wildcards = yamlWildcards.filter(x => {
+                let tags = x[1];
+                const matchesNeg =
+                    matches.negative.length === 0
+                    || matches.negative.every(x => 
+                        x.hasCursor 
+                        || x.tags.every(t => !tags[t])
+                    );
+                if (!matchesNeg) return false;
+                const matchesPos =
+                    matches.positive.length === 0
+                    || matches.positive.every(x =>
+                        x.hasCursor
+                        || x.tags.every(t => tags[t])
+                    );
+                if (!matchesPos) return false;
+                const matchesOpt =
+                    matches.optional.length === 0
+                    || matches.optional.some(x =>
+                        x.tags.some(t =>
+                            t.hasCursor
+                            || t.isNegative
+                                ? !tags[t.tag]
+                                : tags[t.tag]
+                    ));
+                if (!matchesOpt) return false;
+                return true;
+            }).reduce((acc, val) => {
+                Object.keys(val[1]).forEach(tag => acc[tag] = acc[tag] + 1 || 1);
+                return acc;
+            }, {});
+
+            return Object.entries(wildcards)
+                .sort((a, b) => b[1] - a[1])
+                .filter(x =>
+                    x[0] === tagword
+                    || !matches.all.includes(x[0])
+                );
+        }
+        
+        if (umiTags.length > 0) {
+            // Get difference for subprompt
+            let tagCountChange = umiTags.length - umiPreviousTags.length;
+            let diff = difference(umiTags, umiPreviousTags);
+            umiPreviousTags = umiTags;
+
+            // Show all condition
+            let showAll = tagword.endsWith("[") || tagword.endsWith("[--") || tagword.endsWith("|");
+
+            // Exit early if the user closed the bracket manually
+            if ((!diff || diff.length === 0 || (diff.length === 1 && tagCountChange < 0)) && !showAll) {
+                if (!hideBlocked) hideResults(textArea);
+                return;
+            }
+
+            let umiTagword = diff[0] || '';
+            let tempResults = [];
+            if (umiTagword && umiTagword.length > 0) {
+                umiTagword = umiTagword.toLowerCase().replace(/[\n\r]/g, "");
+                originalTagword = tagword;
+                tagword = umiTagword;
+                let filteredWildcardsSorted = filteredWildcards(umiTagword);
+                let searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(umiTagword)}`, 'i')
+                let baseFilter = x => x[0].toLowerCase().search(searchRegex) > -1;
+                let spaceIncludeFilter = x => x[0].toLowerCase().replaceAll(" ", "_").search(searchRegex) > -1;
+                tempResults = filteredWildcardsSorted.filter(x => baseFilter(x) || spaceIncludeFilter(x)) // Filter by tagword
+
+                // Add final results
+                let finalResults = [];
+                tempResults.forEach(t => {
+                    let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
+                    result.count = t[1];
+                    finalResults.push(result);
+                });
+
+                return finalResults;
+            } else if (showAll) {
+                let filteredWildcardsSorted = filteredWildcards("");
+                
+                // Add final results
+                let finalResults = [];
+                filteredWildcardsSorted.forEach(t => {
+                    let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
+                    result.count = t[1];
+                    finalResults.push(result);
+                });
+        
+                originalTagword = tagword;
+                tagword = "";
+                return finalResults;
+            }
+        } else {
+            let filteredWildcardsSorted = filteredWildcards("");
+                
+            // Add final results
+            let finalResults = [];
+            filteredWildcardsSorted.forEach(t => {
+                let result = new AutocompleteResult(t[0].trim(), ResultType.yamlWildcard)
+                result.count = t[1];
+                finalResults.push(result);
+            });
+
+            originalTagword = tagword;
+            tagword = "";
+            return finalResults;
+        }
+    }
+}
+
+function updateUmiTags( tagType, sanitizedText, newPrompt, textArea) {
+    // If it was a yaml wildcard, also update the umiPreviousTags
+    if (tagType === ResultType.yamlWildcard && originalTagword.length > 0) {
+        let umiSubPrompts = [...newPrompt.matchAll(UMI_PROMPT_REGEX)];
+
+        let umiTags = [];
+        umiSubPrompts.forEach(umiSubPrompt => {
+            umiTags = umiTags.concat([...umiSubPrompt[0].matchAll(UMI_TAG_REGEX)].map(x => x[1].toLowerCase()));
+        });
+
+        umiPreviousTags = umiTags;
+
+        hideResults(textArea);
+
+        return true;
+    }
+    return false;
+}
+
+async function load() {
+    if (yamlWildcards.length === 0) {
+        try {
+            let yamlTags = (await readFile(`${tagBasePath}/temp/wcet.txt`)).split("\n");
+            // Split into tag, count pairs
+            yamlWildcards = yamlTags.map(x => x
+                .trim()
+                .split(","))
+                .map(([i, ...rest]) => [
+                    i,
+                    rest.reduce((a, b) => {
+                        a[b.toLowerCase()] = true;
+                        return a;
+                    }, {}),
+                ]);
+        } catch (e) {
+            console.error("Error loading yaml wildcards: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    // Replace underscores only if the yaml tag is not using them
+    if (tagType === ResultType.yamlWildcard && !yamlWildcards.includes(text)) {
+        return text.replaceAll("_", " "); 
+    }
+    return null;
+}
+
+// Add UMI parser
+PARSERS.push(new UmiParser(UMI_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);
+QUEUE_AFTER_INSERT.push(updateUmiTags);

a1111-microsoftexcel-tagcomplete/javascript/ext_wildcards.js

@@ -0,0 +1,123 @@
+// Regex
+const WC_REGEX = /\b__([^,]+)__([^, ]*)\b/g;
+
+// Trigger conditions
+const WC_TRIGGER = () => CFG.useWildcards && [...tagword.matchAll(WC_REGEX)].length > 0;
+const WC_FILE_TRIGGER = () => CFG.useWildcards && (tagword.startsWith("__") && !tagword.endsWith("__") || tagword === "__");
+
+class WildcardParser extends BaseTagParser {
+    async parse() {
+        // Show wildcards from a file with that name
+        let wcMatch = [...tagword.matchAll(WC_REGEX)]
+        let wcFile = wcMatch[0][1];
+        let wcWord = wcMatch[0][2];
+
+        // Look in normal wildcard files
+        let wcFound = wildcardFiles.find(x => x[1].toLowerCase() === wcFile);
+        // Use found wildcard file or look in external wildcard files
+        let wcPair = wcFound || wildcardExtFiles.find(x => x[1].toLowerCase() === wcFile);
+
+        let wildcards = (await readFile(`${wcPair[0]}/${wcPair[1]}.txt`)).split("\n")
+            .filter(x => x.trim().length > 0 && !x.startsWith('#'));  // Remove empty lines and comments
+
+        let finalResults = [];
+        let tempResults = wildcards.filter(x => (wcWord !== null && wcWord.length > 0) ? x.toLowerCase().includes(wcWord) : x) // Filter by tagword
+        tempResults.forEach(t => {
+            let result = new AutocompleteResult(t.trim(), ResultType.wildcardTag);
+            result.meta = wcFile;
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+class WildcardFileParser extends BaseTagParser {
+    parse() {
+        // Show available wildcard files
+        let tempResults = [];
+        if (tagword !== "__") {
+            let lmb = (x) => x[1].toLowerCase().includes(tagword.replace("__", ""))
+            tempResults = wildcardFiles.filter(lmb).concat(wildcardExtFiles.filter(lmb)) // Filter by tagword
+        } else {
+            tempResults = wildcardFiles.concat(wildcardExtFiles);
+        }
+
+        let finalResults = [];
+        // Get final results
+        tempResults.forEach(wcFile => {
+            let result = new AutocompleteResult(wcFile[1].trim(), ResultType.wildcardFile);
+            result.meta = "Wildcard file";
+            finalResults.push(result);
+        });
+
+        return finalResults;
+    }
+}
+
+async function load() {
+    if (wildcardFiles.length === 0 && wildcardExtFiles.length === 0) {
+        try {
+            let wcFileArr = (await readFile(`${tagBasePath}/temp/wc.txt`)).split("\n");
+            let wcBasePath = wcFileArr[0].trim(); // First line should be the base path
+            wildcardFiles = wcFileArr.slice(1)
+                .filter(x => x.trim().length > 0) // Remove empty lines
+                .map(x => [wcBasePath, x.trim().replace(".txt", "")]); // Remove file extension & newlines
+
+            // To support multiple sources, we need to separate them using the provided "-----" strings
+            let wcExtFileArr = (await readFile(`${tagBasePath}/temp/wce.txt`)).split("\n");
+            let splitIndices = [];
+            for (let index = 0; index < wcExtFileArr.length; index++) {
+                if (wcExtFileArr[index].trim() === "-----") {
+                    splitIndices.push(index);
+                }
+            }
+            // For each group, add them to the wildcardFiles array with the base path as the first element
+            for (let i = 0; i < splitIndices.length; i++) {
+                let start = splitIndices[i - 1] || 0;
+                if (i > 0) start++; // Skip the "-----" line
+                let end = splitIndices[i];
+
+                let wcExtFile = wcExtFileArr.slice(start, end);
+                let base = wcExtFile[0].trim() + "/";
+                wcExtFile = wcExtFile.slice(1)
+                    .filter(x => x.trim().length > 0) // Remove empty lines
+                    .map(x => x.trim().replace(base, "").replace(".txt", "")); // Remove file extension & newlines;
+
+                wcExtFile = wcExtFile.map(x => [base, x]);
+                wildcardExtFiles.push(...wcExtFile);
+            }
+        } catch (e) {
+            console.error("Error loading wildcards: " + e);
+        }
+    }
+}
+
+function sanitize(tagType, text) {
+    if (tagType === ResultType.wildcardFile) {
+        return `__${text}__`;
+    } else if (tagType === ResultType.wildcardTag) {
+        return text.replace(/^.*?: /g, "");
+    }
+    return null;
+}
+
+function keepOpenIfWildcard(tagType, sanitizedText, newPrompt, textArea) {
+    // If it's a wildcard, we want to keep the results open so the user can select another wildcard
+    if (tagType === ResultType.wildcardFile) {
+        hideBlocked = true;
+        autocomplete(textArea, newPrompt, sanitizedText);
+        setTimeout(() => { hideBlocked = false; }, 100);
+        return true;
+    }
+    return false;
+}
+
+// Register the parsers
+PARSERS.push(new WildcardParser(WC_TRIGGER));
+PARSERS.push(new WildcardFileParser(WC_FILE_TRIGGER));
+
+// Add our utility functions to their respective queues
+QUEUE_FILE_LOAD.push(load);
+QUEUE_SANITIZE.push(sanitize);
+QUEUE_AFTER_INSERT.push(keepOpenIfWildcard);

a1111-microsoftexcel-tagcomplete/javascript/tagAutocomplete.js

@@ -0,0 +1,935 @@
+const styleColors = {
+    "--results-bg": ["#0b0f19", "#ffffff"],
+    "--results-border-color": ["#4b5563", "#e5e7eb"],
+    "--results-border-width": ["1px", "1.5px"],
+    "--results-bg-odd": ["#111827", "#f9fafb"],
+    "--results-hover": ["#1f2937", "#f5f6f8"],
+    "--results-selected": ["#374151", "#e5e7eb"],
+    "--meta-text-color": ["#6b6f7b", "#a2a9b4"],
+    "--embedding-v1-color": ["lightsteelblue", "#2b5797"],
+    "--embedding-v2-color": ["skyblue", "#2d89ef"],
+}
+const browserVars = {
+    "--results-overflow-y": {
+        "firefox": "scroll",
+        "other": "auto"
+    }
+}
+// Style for new elements. Gets appended to the Gradio root.
+const autocompleteCSS = `
+    #quicksettings [id^=setting_tac] {
+        background-color: transparent;
+        min-width: fit-content;
+    }
+    .autocompleteResults {
+        position: absolute;
+        z-index: 999;
+        max-width: calc(100% - 1.5rem);
+        margin: 5px 0 0 0;
+        background-color: var(--results-bg) !important;
+        border: var(--results-border-width) solid var(--results-border-color) !important;
+        border-radius: 12px !important;
+        overflow-y: var(--results-overflow-y);
+        overflow-x: hidden;
+        word-break: break-word;
+    }
+    .autocompleteResultsList > li:nth-child(odd) {
+        background-color: var(--results-bg-odd);
+    }
+    .autocompleteResultsList > li {
+        list-style-type: none;
+        padding: 10px;
+        cursor: pointer;
+    }
+    .autocompleteResultsList > li:hover {
+        background-color: var(--results-hover);
+    }
+    .autocompleteResultsList > li.selected {
+        background-color: var(--results-selected);
+    }
+    .resultsFlexContainer {
+        display: flex;
+    }
+    .acListItem {
+        white-space: break-spaces;
+    }
+    .acMetaText {
+        position: relative;
+        flex-grow: 1;
+        text-align: end;
+        padding: 0 0 0 15px;
+        white-space: nowrap;
+        color: var(--meta-text-color);
+    }
+    .acWikiLink {
+        padding: 0.5rem;
+        margin: -0.5rem 0 -0.5rem -0.5rem;
+    }
+    .acWikiLink:hover {
+        text-decoration: underline;
+    }
+    .acListItem.acEmbeddingV1 {
+        color: var(--embedding-v1-color);
+    }
+    .acListItem.acEmbeddingV2 {
+        color: var(--embedding-v2-color);
+    }
+`;
+
+async function loadTags(c) {
+    // Load main tags and aliases
+    if (allTags.length === 0 && c.tagFile && c.tagFile !== "None") {
+        try {
+            allTags = await loadCSV(`${tagBasePath}/${c.tagFile}`);
+        } catch (e) {
+            console.error("Error loading tags file: " + e);
+            return;
+        }
+    }
+    await loadExtraTags(c);
+}
+
+async function loadExtraTags(c) {
+    if (c.extra.extraFile && c.extra.extraFile !== "None") {
+        try {
+            extras = await loadCSV(`${tagBasePath}/${c.extra.extraFile}`);
+            // Add translations to the main translation map for extra tags that have them
+            extras.forEach(e => {
+                if (e[4]) translations.set(e[0], e[4]);
+            });
+        } catch (e) {
+            console.error("Error loading extra file: " + e);
+            return;
+        }
+    }
+}
+
+async function loadTranslations(c) {
+    if (c.translation.translationFile && c.translation.translationFile !== "None") {
+        try {
+            let tArray = await loadCSV(`${tagBasePath}/${c.translation.translationFile}`);
+            tArray.forEach(t => {
+                if (c.translation.oldFormat)
+                    translations.set(t[0], t[2]);
+                else
+                    translations.set(t[0], t[1]);
+            });
+        } catch (e) {
+            console.error("Error loading translations file: " + e);
+            return;
+        }
+    }
+}
+
+async function syncOptions() {
+    let newCFG = {
+        // Main tag file
+        tagFile: opts["tac_tagFile"],
+        // Active in settings
+        activeIn: {
+            global: opts["tac_active"],
+            txt2img: opts["tac_activeIn.txt2img"],
+            img2img: opts["tac_activeIn.img2img"],
+            negativePrompts: opts["tac_activeIn.negativePrompts"],
+            thirdParty: opts["tac_activeIn.thirdParty"],
+            modelList: opts["tac_activeIn.modelList"],
+            modelListMode: opts["tac_activeIn.modelListMode"]
+        },
+        // Results related settings
+        slidingPopup: opts["tac_slidingPopup"],
+        maxResults: opts["tac_maxResults"],
+        showAllResults: opts["tac_showAllResults"],
+        resultStepLength: opts["tac_resultStepLength"],
+        delayTime: opts["tac_delayTime"],
+        useWildcards: opts["tac_useWildcards"],
+        useEmbeddings: opts["tac_useEmbeddings"],
+        useHypernetworks: opts["tac_useHypernetworks"],
+        useLoras: opts["tac_useLoras"],
+	useLycos: opts["tac_useLycos"],
+        showWikiLinks: opts["tac_showWikiLinks"],
+        // Insertion related settings
+        replaceUnderscores: opts["tac_replaceUnderscores"],
+        escapeParentheses: opts["tac_escapeParentheses"],
+        appendComma: opts["tac_appendComma"],
+        // Alias settings
+        alias: {
+            searchByAlias: opts["tac_alias.searchByAlias"],
+            onlyShowAlias: opts["tac_alias.onlyShowAlias"]
+        },
+        // Translation settings
+        translation: {
+            translationFile: opts["tac_translation.translationFile"],
+            oldFormat: opts["tac_translation.oldFormat"],
+            searchByTranslation: opts["tac_translation.searchByTranslation"],
+        },
+        // Extra file settings
+        extra: {
+            extraFile: opts["tac_extra.extraFile"],
+            addMode: opts["tac_extra.addMode"]
+        },
+        // Settings not from tac but still used by the script
+        extraNetworksDefaultMultiplier: opts["extra_networks_default_multiplier"],
+        extraNetworksSeparator: opts["extra_networks_add_text_separator"],
+        // Custom mapping settings
+        keymap: JSON.parse(opts["tac_keymap"]),
+        colorMap: JSON.parse(opts["tac_colormap"])
+    }
+    if (newCFG.alias.onlyShowAlias) {
+        newCFG.alias.searchByAlias = true; // if only show translation, enable search by translation is necessary
+    }
+
+    // Reload translations if the translation file changed
+    if (!CFG || newCFG.translation.translationFile !== CFG.translation.translationFile) {
+        translations.clear();
+        await loadTranslations(newCFG);
+        await loadExtraTags(newCFG);
+    }
+    // Reload tags if the tag file changed (after translations so extra tag translations get re-added)
+    if (!CFG || newCFG.tagFile !== CFG.tagFile || newCFG.extra.extraFile !== CFG.extra.extraFile) {
+        allTags = [];
+        await loadTags(newCFG);
+    }
+
+    // Update CSS if maxResults changed
+    if (CFG && newCFG.maxResults !== CFG.maxResults) {
+        gradioApp().querySelectorAll(".autocompleteResults").forEach(r => {
+            r.style.maxHeight = `${newCFG.maxResults * 50}px`;
+        });
+    }
+
+    // Apply changes
+    CFG = newCFG;
+
+    // Callback
+    await processQueue(QUEUE_AFTER_CONFIG_CHANGE, null);
+}
+
+// Create the result list div and necessary styling
+function createResultsDiv(textArea) {
+    let resultsDiv = document.createElement("div");
+    let resultsList = document.createElement("ul");
+
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let typeClass = textAreaId.replaceAll(".", " ");
+
+    resultsDiv.style.maxHeight = `${CFG.maxResults * 50}px`;
+    resultsDiv.setAttribute("class", `autocompleteResults ${typeClass} notranslate`);
+    resultsDiv.setAttribute("translate", "no");
+    resultsList.setAttribute("class", "autocompleteResultsList");
+    resultsDiv.appendChild(resultsList);
+
+    return resultsDiv;
+}
+
+// Show or hide the results div
+function isVisible(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    return resultsDiv.style.display === "block";
+}
+function showResults(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    resultsDiv.style.display = "block";
+
+    if (CFG.slidingPopup) {
+        let caretPosition = getCaretCoordinates(textArea, textArea.selectionEnd).left;
+        let offset = Math.min(textArea.offsetLeft - textArea.scrollLeft + caretPosition, textArea.offsetWidth - resultsDiv.offsetWidth);
+    
+        resultsDiv.style.left = `${offset}px`;
+    } else {
+        if (resultsDiv.style.left)
+            resultsDiv.style.removeProperty("left");
+    }
+}
+function hideResults(textArea) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultsDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    
+    if (!resultsDiv) return;
+    
+    resultsDiv.style.display = "none";
+    selectedTag = null;
+}
+
+// Function to check activation criteria
+function isEnabled() {
+    if (CFG.activeIn.global) {
+        // Skip check if the current model was not correctly detected, since it could wrongly disable the script otherwise
+        if (!currentModelName || !currentModelHash) return true;
+        
+        let modelList = CFG.activeIn.modelList
+            .split(",")
+            .map(x => x.trim())
+            .filter(x => x.length > 0);
+        
+        let shortHash = currentModelHash.substring(0, 10);
+        let modelNameWithoutHash = currentModelName.replace(/\[.*\]$/g, "").trim();
+        if (CFG.activeIn.modelListMode.toLowerCase() === "blacklist") {
+            // If the current model is in the blacklist, disable
+            return modelList.filter(x => x === currentModelName || x === modelNameWithoutHash || x === currentModelHash || x === shortHash).length === 0;
+        } else {
+            // If the current model is in the whitelist, enable.
+            // An empty whitelist is ignored.
+            return modelList.length === 0 || modelList.filter(x => x === currentModelName || x === modelNameWithoutHash || x === currentModelHash || x === shortHash).length > 0;
+        }
+    } else {
+        return false;
+    }
+}
+
+const WEIGHT_REGEX = /[([]([^()[\]:|]+)(?::(?:\d+(?:\.\d+)?|\.\d+))?[)\]]/g;
+const POINTY_REGEX = /<[^\s,<](?:[^\t\n\r,<>]*>|[^\t\n\r,> ]*)/g;
+const COMPLETED_WILDCARD_REGEX = /__[^\s,_][^\t\n\r,_]*[^\s,_]__[^\s,_]*/g;
+const NORMAL_TAG_REGEX = /[^\s,|<>)\]]+|</g;
+const TAG_REGEX = new RegExp(`${POINTY_REGEX.source}|${COMPLETED_WILDCARD_REGEX.source}|${NORMAL_TAG_REGEX.source}`, "g");
+
+// On click, insert the tag into the prompt textbox with respect to the cursor position
+async function insertTextAtCursor(textArea, result, tagword) {
+    let text = result.text;
+    let tagType = result.type;
+
+    let cursorPos = textArea.selectionStart;
+    var sanitizedText = text
+
+    // Run sanitize queue and use first result as sanitized text
+    sanitizeResults = await processQueueReturn(QUEUE_SANITIZE, null, tagType, text);
+
+    if (sanitizeResults && sanitizeResults.length > 0) {
+        sanitizedText = sanitizeResults[0];
+    } else {
+        sanitizedText = CFG.replaceUnderscores ? text.replaceAll("_", " ") : text;
+
+        if (CFG.escapeParentheses && tagType === ResultType.tag) {
+            sanitizedText = sanitizedText
+                .replaceAll("(", "\\(")
+                .replaceAll(")", "\\)")
+                .replaceAll("[", "\\[")
+                .replaceAll("]", "\\]");
+        }
+    }
+
+    var prompt = textArea.value;
+
+    // Edit prompt text
+    let editStart = Math.max(cursorPos - tagword.length, 0);
+    let editEnd = Math.min(cursorPos + tagword.length, prompt.length);
+    let surrounding = prompt.substring(editStart, editEnd);
+    let match = surrounding.match(new RegExp(escapeRegExp(`${tagword}`), "i"));
+    let afterInsertCursorPos = editStart + match.index + sanitizedText.length;
+
+    var optionalSeparator = "";
+    let extraNetworkTypes = [ResultType.hypernetwork, ResultType.lora];
+    let noCommaTypes = [ResultType.wildcardFile, ResultType.yamlWildcard].concat(extraNetworkTypes);
+    if (CFG.appendComma && !noCommaTypes.includes(tagType)) {
+        optionalSeparator = surrounding.match(new RegExp(`${escapeRegExp(tagword)}[,:]`, "i")) !== null ? "" : ", ";
+    } else if (extraNetworkTypes.includes(tagType)) {
+        // Use the dedicated separator for extra networks if it's defined, otherwise fall back to space
+        optionalSeparator = CFG.extraNetworksSeparator || " ";
+    }
+
+    // Replace partial tag word with new text, add comma if needed
+    let insert = surrounding.replace(match, sanitizedText + optionalSeparator);
+
+    // Add back start
+    var newPrompt = prompt.substring(0, editStart) + insert + prompt.substring(editEnd);
+    textArea.value = newPrompt;
+    textArea.selectionStart = afterInsertCursorPos + optionalSeparator.length;
+    textArea.selectionEnd = textArea.selectionStart
+
+    // Since we've modified a Gradio Textbox component manually, we need to simulate an `input` DOM event to ensure it's propagated back to python.
+    // Uses a built-in method from the webui's ui.js which also already accounts for event target
+    updateInput(textArea);
+
+    // Update previous tags with the edited prompt to prevent re-searching the same term
+    let weightedTags = [...newPrompt.matchAll(WEIGHT_REGEX)]
+            .map(match => match[1]);
+    let tags = newPrompt.match(TAG_REGEX)
+    if (weightedTags !== null) {
+        tags = tags.filter(tag => !weightedTags.some(weighted => tag.includes(weighted)))
+            .concat(weightedTags);
+    }
+    previousTags = tags;
+
+    // Callback
+    let returns = await processQueueReturn(QUEUE_AFTER_INSERT, null, tagType, sanitizedText, newPrompt, textArea);
+    // Return if any queue function returned true (has handled hide/show already)
+    if (returns.some(x => x === true))
+        return;
+
+    // Hide results after inserting, if it hasn't been hidden already by a queue function
+    if (!hideBlocked && isVisible(textArea)) {
+        hideResults(textArea);
+    }
+}
+
+function addResultsToList(textArea, results, tagword, resetList) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    let resultsList = resultDiv.querySelector('ul');
+
+    // Reset list, selection and scrollTop since the list changed
+    if (resetList) {
+        resultsList.innerHTML = "";
+        selectedTag = null;
+        resultDiv.scrollTop = 0;
+        resultCount = 0;
+    }
+
+    // Find right colors from config
+    let tagFileName = CFG.tagFile.split(".")[0];
+    let tagColors = CFG.colorMap;
+    let mode = (document.querySelector(".dark") || gradioApp().querySelector(".dark")) ? 0 : 1;
+    let nextLength = Math.min(results.length, resultCount + CFG.resultStepLength);
+
+    for (let i = resultCount; i < nextLength; i++) {
+        let result = results[i];
+
+        // Skip if the result is null or undefined
+        if (!result)
+            continue;
+
+        let li = document.createElement("li");
+
+        let flexDiv = document.createElement("div");
+        flexDiv.classList.add("resultsFlexContainer");
+        li.appendChild(flexDiv);
+
+        let itemText = document.createElement("div");
+        itemText.classList.add("acListItem");
+
+        let displayText = "";
+        // If the tag matches the tagword, we don't need to display the alias
+        if (result.aliases && !result.text.includes(tagword)) { // Alias
+            let splitAliases = result.aliases.split(",");
+            let bestAlias = splitAliases.find(a => a.toLowerCase().includes(tagword));
+
+            // search in translations if no alias matches
+            if (!bestAlias) {
+                let tagOrAlias = pair => pair[0] === result.text || splitAliases.includes(pair[0]);
+                var tArray = [...translations];
+                if (tArray) {
+                    var translationKey = [...translations].find(pair => tagOrAlias(pair) && pair[1].includes(tagword));
+                    if (translationKey)
+                        bestAlias = translationKey[0];
+                }
+            }
+
+            displayText = escapeHTML(bestAlias);
+
+            // Append translation for alias if it exists and is not what the user typed
+            if (translations.has(bestAlias) && translations.get(bestAlias) !== bestAlias && bestAlias !== result.text)
+                displayText += `[${translations.get(bestAlias)}]`;
+
+            if (!CFG.alias.onlyShowAlias && result.text !== bestAlias)
+                displayText += " ➝ " + result.text;
+        } else { // No alias
+            displayText = escapeHTML(result.text);
+        }
+
+        // Append translation for result if it exists
+        if (translations.has(result.text))
+            displayText += `[${translations.get(result.text)}]`;
+
+        // Print search term bolded in result
+        itemText.innerHTML = displayText.replace(tagword, `<b>${tagword}</b>`);
+
+        // Add wiki link if the setting is enabled and a supported tag set loaded
+        if (CFG.showWikiLinks
+            && (result.type === ResultType.tag)
+            && (tagFileName.toLowerCase().startsWith("danbooru") || tagFileName.toLowerCase().startsWith("e621"))) {
+            let wikiLink = document.createElement("a");
+            wikiLink.classList.add("acWikiLink");
+            wikiLink.innerText = "?";
+
+            let linkPart = displayText;
+            // Only use alias result if it is one
+            if (displayText.includes("➝"))
+                linkPart = displayText.split(" ➝ ")[1];
+            
+            // Set link based on selected file
+            let tagFileNameLower = tagFileName.toLowerCase();
+            if (tagFileNameLower.startsWith("danbooru")) {
+                wikiLink.href = `https://danbooru.donmai.us/wiki_pages/${linkPart}`;
+            } else if (tagFileNameLower.startsWith("e621")) {
+                wikiLink.href = `https://e621.net/wiki_pages/${linkPart}`;
+            }
+            
+            wikiLink.target = "_blank";
+            flexDiv.appendChild(wikiLink);
+        }
+
+        flexDiv.appendChild(itemText);
+
+        // Add post count & color if it's a tag
+        // Wildcards & Embeds have no tag category
+        if (result.category) {
+            // Set the color of the tag
+            let cat = result.category;
+            let colorGroup = tagColors[tagFileName];
+            // Default to danbooru scheme if no matching one is found
+            if (!colorGroup)
+                colorGroup = tagColors["danbooru"];
+
+            // Set tag type to invalid if not found
+            if (!colorGroup[cat])
+                cat = "-1";
+
+            flexDiv.style = `color: ${colorGroup[cat][mode]};`;
+        }
+
+        // Post count
+        if (result.count && !isNaN(result.count)) {
+            let postCount = result.count;
+            let formatter;
+
+            // Danbooru formats numbers with a padded fraction for 1M or 1k, but not for 10/100k
+            if (postCount >= 1000000 || (postCount >= 1000 && postCount < 10000))
+                formatter = Intl.NumberFormat("en", { notation: "compact", minimumFractionDigits: 1, maximumFractionDigits: 1 });
+            else
+                formatter = Intl.NumberFormat("en", {notation: "compact"});
+
+            let formattedCount = formatter.format(postCount);
+
+            let countDiv = document.createElement("div");
+            countDiv.textContent = formattedCount;
+            countDiv.classList.add("acMetaText");
+            flexDiv.appendChild(countDiv);
+        } else if (result.meta) { // Check if there is meta info to display
+            let metaDiv = document.createElement("div");
+            metaDiv.textContent = result.meta;
+            metaDiv.classList.add("acMetaText");
+
+            // Add version info classes if it is an embedding
+            if (result.type === ResultType.embedding) {
+                if (result.meta.startsWith("v1"))
+                    itemText.classList.add("acEmbeddingV1");
+                else if (result.meta.startsWith("v2"))
+                    itemText.classList.add("acEmbeddingV2");
+            }
+                
+            flexDiv.appendChild(metaDiv);
+        }
+
+        // Add listener
+        li.addEventListener("click", function () { insertTextAtCursor(textArea, result, tagword); });
+        // Add element to list
+        resultsList.appendChild(li);
+    }
+    resultCount = nextLength;
+
+    if (resetList)
+        resultDiv.scrollTop = 0;
+}
+
+function updateSelectionStyle(textArea, newIndex, oldIndex) {
+    let textAreaId = getTextAreaIdentifier(textArea);
+    let resultDiv = gradioApp().querySelector('.autocompleteResults' + textAreaId);
+    let resultsList = resultDiv.querySelector('ul');
+    let items = resultsList.getElementsByTagName('li');
+
+    if (oldIndex != null) {
+        items[oldIndex].classList.remove('selected');
+    }
+
+    // make it safer
+    if (newIndex !== null) {
+        items[newIndex].classList.add('selected');
+    }
+
+    // Set scrolltop to selected item if we are showing more than max results
+    if (items.length > CFG.maxResults) {
+        let selected = items[newIndex];
+        resultDiv.scrollTop = selected.offsetTop - resultDiv.offsetTop;
+    }
+}
+
+async function autocomplete(textArea, prompt, fixedTag = null) {
+    // Return if the function is deactivated in the UI
+    if (!isEnabled()) return;
+
+    // Guard for empty prompt
+    if (prompt.length === 0) {
+        hideResults(textArea);
+        previousTags = [];
+        tagword = "";
+        return;
+    }
+
+    if (fixedTag === null) {
+        // Match tags with RegEx to get the last edited one
+        // We also match for the weighting format (e.g. "tag:1.0") here, and combine the two to get the full tag word set
+        let weightedTags = [...prompt.matchAll(WEIGHT_REGEX)]
+            .map(match => match[1]);
+        let tags = prompt.match(TAG_REGEX)
+        if (weightedTags !== null && tags !== null) {
+            tags = tags.filter(tag => !weightedTags.some(weighted => tag.includes(weighted) && !tag.startsWith("<[")))
+                .concat(weightedTags);
+        }
+
+        // Guard for no tags
+        if (!tags || tags.length === 0) {
+            previousTags = [];
+            tagword = "";
+            hideResults(textArea);
+            return;
+        }
+
+        let tagCountChange = tags.length - previousTags.length;
+        let diff = difference(tags, previousTags);
+        previousTags = tags;
+
+        // Guard for no difference / only whitespace remaining / last edited tag was fully removed
+        if (diff === null || diff.length === 0 || (diff.length === 1 && tagCountChange < 0)) {
+            if (!hideBlocked) hideResults(textArea);
+            return;
+        }
+
+        tagword = diff[0]
+
+        // Guard for empty tagword
+        if (tagword === null || tagword.length === 0) {
+            hideResults(textArea);
+            return;
+        }
+    } else {
+        tagword = fixedTag;
+    }
+
+    results = [];
+    tagword = tagword.toLowerCase().replace(/[\n\r]/g, "");
+
+    // Process all parsers
+    let resultCandidates = await processParsers(textArea, prompt);
+    // If one ore more result candidates match, use their results
+    if (resultCandidates && resultCandidates.length > 0) {
+        // Flatten our candidate(s)
+        results = resultCandidates.flat();
+        // If there was more than one candidate, sort the results by text to mix them
+        // instead of having them added in the order of the parsers
+        let shouldSort = resultCandidates.length > 1;
+        if (shouldSort) {
+            results = results.sort((a, b) => a.text.localeCompare(b.text));
+
+            // Since some tags are kaomoji, we have to add the normal results in some cases
+            if (tagword.startsWith("<") || tagword.startsWith("*<")) {
+                // Create escaped search regex with support for * as a start placeholder
+                let searchRegex;
+                if (tagword.startsWith("*")) {
+                    tagword = tagword.slice(1);
+                    searchRegex = new RegExp(`${escapeRegExp(tagword)}`, 'i');
+                } else {
+                    searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(tagword)}`, 'i');
+                }
+                let genericResults = allTags.filter(x => x[0].toLowerCase().search(searchRegex) > -1).slice(0, CFG.maxResults);
+
+                genericResults.forEach(g => {
+                    let result = new AutocompleteResult(g[0].trim(), ResultType.tag)
+                    result.category = g[1];
+                    result.count = g[2];
+                    result.aliases = g[3];
+                    results.push(result);
+                });
+            }
+        }
+    } else { // Else search the normal tag list
+        // Create escaped search regex with support for * as a start placeholder
+        let searchRegex;
+        if (tagword.startsWith("*")) {
+            tagword = tagword.slice(1);
+            searchRegex = new RegExp(`${escapeRegExp(tagword)}`, 'i');
+        } else {
+            searchRegex = new RegExp(`(^|[^a-zA-Z])${escapeRegExp(tagword)}`, 'i');
+        }
+
+        // Both normal tags and aliases/translations are included depending on the config
+        let baseFilter = (x) => x[0].toLowerCase().search(searchRegex) > -1;
+        let aliasFilter = (x) => x[3] && x[3].toLowerCase().search(searchRegex) > -1;
+        let translationFilter = (x) => (translations.has(x[0]) && translations.get(x[0]).toLowerCase().search(searchRegex) > -1)
+            || x[3] && x[3].split(",").some(y => translations.has(y) && translations.get(y).toLowerCase().search(searchRegex) > -1);
+        
+        let fil;
+        if (CFG.alias.searchByAlias && CFG.translation.searchByTranslation)
+            fil = (x) => baseFilter(x) || aliasFilter(x) || translationFilter(x);
+        else if (CFG.alias.searchByAlias && !CFG.translation.searchByTranslation)
+            fil = (x) => baseFilter(x) || aliasFilter(x);
+        else if (CFG.translation.searchByTranslation && !CFG.alias.searchByAlias)
+            fil = (x) => baseFilter(x) || translationFilter(x);
+        else
+            fil = (x) => baseFilter(x);
+
+        // Add final results
+        allTags.filter(fil).forEach(t => {
+            let result = new AutocompleteResult(t[0].trim(), ResultType.tag)
+            result.category = t[1];
+            result.count = t[2];
+            result.aliases = t[3];
+            results.push(result);
+        });
+
+        // Add extras
+        if (CFG.extra.extraFile) {
+            let extraResults = [];
+
+            extras.filter(fil).forEach(e => {
+                let result = new AutocompleteResult(e[0].trim(), ResultType.extra)
+                result.category = e[1] || 0; // If no category is given, use 0 as the default
+                result.meta = e[2] || "Custom tag";
+                result.aliases = e[3] || "";
+                extraResults.push(result);
+            });
+
+            if (CFG.extra.addMode === "Insert before") {
+                results = extraResults.concat(results);
+            } else {
+                results = results.concat(extraResults);
+            }
+        }
+        
+        // Slice if the user has set a max result count
+        if (!CFG.showAllResults) {
+            results = results.slice(0, CFG.maxResults);
+        }
+    }
+
+    // Guard for empty results
+    if (!results || results.length === 0) {
+        //console.log('No results found for "' + tagword + '"');
+        hideResults(textArea);
+        return;
+    }
+
+    addResultsToList(textArea, results, tagword, true);
+    showResults(textArea);
+}
+
+function navigateInList(textArea, event) {
+    // Return if the function is deactivated in the UI or the current model is excluded due to white/blacklist settings
+    if (!isEnabled()) return;
+    
+    let keys = CFG.keymap;
+
+    // Close window if Home or End is pressed while not a keybinding, since it would break completion on leaving the original tag
+    if ((event.key === "Home" || event.key === "End") && !Object.values(keys).includes(event.key)) {
+        hideResults(textArea);
+        return;
+    }
+
+    // All set keys that are not None or empty are valid
+    // Default keys are: ArrowUp, ArrowDown, PageUp, PageDown, Home, End, Enter, Tab, Escape
+    validKeys = Object.values(keys).filter(x => x !== "None" && x !== "");
+
+    if (!validKeys.includes(event.key)) return;
+    if (!isVisible(textArea)) return
+    // Return if ctrl key is pressed to not interfere with weight editing shortcut
+    if (event.ctrlKey || event.altKey) return;
+
+    oldSelectedTag = selectedTag;
+
+    switch (event.key) {
+        case keys["MoveUp"]:
+            if (selectedTag === null) {
+                selectedTag = resultCount - 1;
+            } else {
+                selectedTag = (selectedTag - 1 + resultCount) % resultCount;
+            }
+            break;
+        case keys["MoveDown"]:
+            if (selectedTag === null) {
+                selectedTag = 0;
+            } else {
+                selectedTag = (selectedTag + 1) % resultCount;
+            }
+            break;
+        case keys["JumpUp"]:
+            if (selectedTag === null || selectedTag === 0) {
+                selectedTag = resultCount - 1;
+            } else {
+                selectedTag = (Math.max(selectedTag - 5, 0) + resultCount) % resultCount;
+            }
+            break;
+        case keys["JumpDown"]:
+            if (selectedTag === null || selectedTag === resultCount - 1) {
+                selectedTag = 0;
+            } else {
+                selectedTag = Math.min(selectedTag + 5, resultCount - 1) % resultCount;
+            }
+            break;
+        case keys["JumpToStart"]:
+            selectedTag = 0;
+            break;
+        case keys["JumpToEnd"]:
+            selectedTag = resultCount - 1;
+            break;
+        case keys["ChooseSelected"]:
+            if (selectedTag !== null) {
+                insertTextAtCursor(textArea, results[selectedTag], tagword);
+            } else {
+                hideResults(textArea);
+                return;
+            }
+            break;
+        case keys["ChooseFirstOrSelected"]:
+            if (selectedTag === null) {
+                selectedTag = 0;
+            }
+            insertTextAtCursor(textArea, results[selectedTag], tagword);
+            break;
+        case keys["Close"]:
+            hideResults(textArea);
+            break;
+    }
+    if (selectedTag === resultCount - 1
+        && (event.key === keys["MoveUp"] || event.key === keys["MoveDown"] || event.key === keys["JumpToStart"] || event.key === keys["JumpToEnd"])) {
+        addResultsToList(textArea, results, tagword, false);
+    }
+    // Update highlighting
+    if (selectedTag !== null)
+        updateSelectionStyle(textArea, selectedTag, oldSelectedTag);
+
+    // Prevent default behavior
+    event.preventDefault();
+    event.stopPropagation();
+}
+
+function addAutocompleteToArea(area) {
+    // Return if autocomplete is disabled for the current area type in config
+    let textAreaId = getTextAreaIdentifier(area);
+    if ((!CFG.activeIn.img2img && textAreaId.includes("img2img"))
+        || (!CFG.activeIn.txt2img && textAreaId.includes("txt2img"))
+        || (!CFG.activeIn.negativePrompts && textAreaId.includes("n"))
+        || (!CFG.activeIn.thirdParty && textAreaId.includes("thirdParty"))) {
+        return;
+    }
+
+    // Only add listeners once
+    if (!area.classList.contains('autocomplete')) {
+        // Add our new element
+        var resultsDiv = createResultsDiv(area);
+        area.parentNode.insertBefore(resultsDiv, area.nextSibling);
+        // Hide by default so it doesn't show up on page load
+        hideResults(area);
+
+        // Add autocomplete event listener
+        area.addEventListener('input', debounce(() => autocomplete(area, area.value), CFG.delayTime));
+        // Add focusout event listener
+        area.addEventListener('focusout', debounce(() => hideResults(area), 400));
+        // Add up and down arrow event listener
+        area.addEventListener('keydown', (e) => navigateInList(area, e));
+        // CompositionEnd fires after the user has finished IME composing
+        // We need to block hide here to prevent the enter key from insta-closing the results
+        area.addEventListener('compositionend', () => {
+            hideBlocked = true;
+            setTimeout(() => { hideBlocked = false; }, 100);
+        });
+
+        // Add class so we know we've already added the listeners
+        area.classList.add('autocomplete');
+    }
+}
+
+// One-time setup, triggered from onUiUpdate
+async function setup() {
+    // Load external files needed by completion extensions
+    await processQueue(QUEUE_FILE_LOAD, null);
+
+    // Find all textareas
+    let textAreas = getTextAreas();
+
+    // Add mutation observer to accordions inside a base that has onDemand set to true
+    addOnDemandObservers(addAutocompleteToArea);
+
+    // Add event listener to apply settings button so we can mirror the changes to our internal config
+    let applySettingsButton = gradioApp().querySelector("#tab_settings #settings_submit") || gradioApp().querySelector("#tab_settings > div > .gr-button-primary");
+    applySettingsButton?.addEventListener("click", () => {
+        // Wait 500ms to make sure the settings have been applied to the webui opts object
+        setTimeout(async () => { 
+            await syncOptions();
+        }, 500);
+    });
+    // Add change listener to our quicksettings to change our internal config without the apply button for them
+    let quicksettings = gradioApp().querySelector('#quicksettings');
+    let commonQueryPart = "[id^=setting_tac] > label >";
+    quicksettings?.querySelectorAll(`${commonQueryPart} input, ${commonQueryPart} textarea, ${commonQueryPart} select`).forEach(e => {
+        e.addEventListener("change", () => {
+            setTimeout(async () => { 
+                await syncOptions();
+            }, 500);
+        });
+    });
+
+    // Add mutation observer for the model hash text to also allow hash-based blacklist again
+    let modelHashText = gradioApp().querySelector("#sd_checkpoint_hash");
+    if (modelHashText) {
+        currentModelHash = modelHashText.title
+        let modelHashObserver = new MutationObserver((mutationList, observer) => {
+            for (const mutation of mutationList) {
+                if (mutation.type === "attributes" && mutation.attributeName === "title") {
+                    currentModelHash = mutation.target.title;
+                    let sdm = gradioApp().querySelector("#setting_sd_model_checkpoint");
+                    let modelDropdown =  sdm.querySelector("input") || sdm.querySelector("#select");
+                    if (modelDropdown) {
+                        currentModelName = modelDropdown.value;
+                    } else {
+                        // Fallback for intermediate versions
+                        modelDropdown = sdm.querySelector("span.single-select");
+                        currentModelName = modelDropdown.textContent;
+                    }
+                }
+            }
+        });
+        modelHashObserver.observe(modelHashText, { attributes: true });
+    }
+
+    // Not found, we're on a page without prompt textareas
+    if (textAreas.every(v => v === null || v === undefined)) return;
+    // Already added or unnecessary to add
+    if (gradioApp().querySelector('.autocompleteResults.p')) {
+        if (gradioApp().querySelector('.autocompleteResults.n') || !CFG.activeIn.negativePrompts) {
+            return;
+        }
+    } else if (!CFG.activeIn.txt2img && !CFG.activeIn.img2img) {
+        return;
+    }
+
+    textAreas.forEach(area => addAutocompleteToArea(area));
+
+    // Add style to dom
+    let acStyle = document.createElement('style');
+    let mode = (document.querySelector(".dark") || gradioApp().querySelector(".dark")) ? 0 : 1;
+    // Check if we are on webkit
+    let browser = navigator.userAgent.toLowerCase().indexOf('firefox') > -1 ? "firefox" : "other";
+    
+    let css = autocompleteCSS;
+    // Replace vars with actual values (can't use actual css vars because of the way we inject the css)
+    Object.keys(styleColors).forEach((key) => {
+        css = css.replace(`var(${key})`, styleColors[key][mode]);
+    })
+    Object.keys(browserVars).forEach((key) => {
+        css = css.replace(`var(${key})`, browserVars[key][browser]);
+    })
+    
+    if (acStyle.styleSheet) {
+        acStyle.styleSheet.cssText = css;
+    } else {
+        acStyle.appendChild(document.createTextNode(css));
+    }
+    gradioApp().appendChild(acStyle);
+
+    // Callback
+    await processQueue(QUEUE_AFTER_SETUP, null);
+}
+let loading = false;
+onUiUpdate(async () => {
+    if (loading) return;
+    if (Object.keys(opts).length === 0) return;
+    if (CFG) return;
+    loading = true;
+    // Get our tag base path from the temp file
+    tagBasePath = await readFile(`tmp/tagAutocompletePath.txt`);
+    // Load config from webui opts
+    await syncOptions();
+    // Rest of setup
+    setup();
+    loading = false;
+});

a1111-microsoftexcel-tagcomplete/scripts/tag_autocomplete_helper.py

@@ -0,0 +1,358 @@
+# This helper script scans folders for wildcards and embeddings and writes them
+# to a temporary file to expose it to the javascript side
+
+import glob
+from pathlib import Path
+
+import gradio as gr
+import yaml
+from modules import script_callbacks, scripts, sd_hijack, shared
+
+try:
+    from modules.paths import extensions_dir, script_path
+
+    # Webui root path
+    FILE_DIR = Path(script_path)
+
+    # The extension base path
+    EXT_PATH = Path(extensions_dir)
+except ImportError:
+    # Webui root path
+    FILE_DIR = Path().absolute()
+    # The extension base path
+    EXT_PATH = FILE_DIR.joinpath('extensions')
+
+# Tags base path
+TAGS_PATH = Path(scripts.basedir()).joinpath('tags')
+
+# The path to the folder containing the wildcards and embeddings
+WILDCARD_PATH = FILE_DIR.joinpath('scripts/wildcards')
+EMB_PATH = Path(shared.cmd_opts.embeddings_dir)
+HYP_PATH = Path(shared.cmd_opts.hypernetwork_dir)
+
+try:
+    LORA_PATH = Path(shared.cmd_opts.lora_dir)
+except AttributeError:
+    LORA_PATH = None
+    
+try:
+    LYCO_PATH = Path(shared.cmd_opts.lyco_dir)
+except AttributeError:
+    LYCO_PATH = None
+
+def find_ext_wildcard_paths():
+    """Returns the path to the extension wildcards folder"""
+    found = list(EXT_PATH.glob('*/wildcards/'))
+    return found
+
+
+# The path to the extension wildcards folder
+WILDCARD_EXT_PATHS = find_ext_wildcard_paths()
+
+# The path to the temporary files
+STATIC_TEMP_PATH = FILE_DIR.joinpath('tmp') # In the webui root, on windows it exists by default, on linux it doesn't
+TEMP_PATH = TAGS_PATH.joinpath('temp') # Extension specific temp files
+
+
+def get_wildcards():
+    """Returns a list of all wildcards. Works on nested folders."""
+    wildcard_files = list(WILDCARD_PATH.rglob("*.txt"))
+    resolved = [w.relative_to(WILDCARD_PATH).as_posix(
+    ) for w in wildcard_files if w.name != "put wildcards here.txt"]
+    return resolved
+
+
+def get_ext_wildcards():
+    """Returns a list of all extension wildcards. Works on nested folders."""
+    wildcard_files = []
+
+    for path in WILDCARD_EXT_PATHS:
+        wildcard_files.append(path.relative_to(FILE_DIR).as_posix())
+        wildcard_files.extend(p.relative_to(path).as_posix() for p in path.rglob("*.txt") if p.name != "put wildcards here.txt")
+        wildcard_files.append("-----")
+
+    return wildcard_files
+
+
+def get_ext_wildcard_tags():
+    """Returns a list of all tags found in extension YAML files found under a Tags: key."""
+    wildcard_tags = {} # { tag: count }
+    yaml_files = []
+    for path in WILDCARD_EXT_PATHS:
+        yaml_files.extend(p for p in path.rglob("*.yml"))
+        yaml_files.extend(p for p in path.rglob("*.yaml"))
+    count = 0
+    for path in yaml_files:
+        try:
+            with open(path, encoding="utf8") as file:
+                data = yaml.safe_load(file)
+                for item in data:
+                    if data[item] and 'Tags' in data[item]:
+                        wildcard_tags[count] = ','.join(data[item]['Tags'])
+                        count += 1
+                    else:
+                        print('Issue with tags found in ' + path.name + ' at item ' + item)
+        except yaml.YAMLError as exc:
+            print(exc)
+    # Sort by count
+    sorted_tags = sorted(wildcard_tags.items(), key=lambda item: item[1], reverse=True)
+    output = []
+    for tag, count in sorted_tags:
+        output.append(f"{tag},{count}")
+    return output
+
+
+def get_embeddings(sd_model):
+    """Write a list of all embeddings with their version"""
+
+    # Version constants
+    V1_SHAPE = 768
+    V2_SHAPE = 1024
+    emb_v1 = []
+    emb_v2 = []
+    results = []
+
+    try:
+        # Get embedding dict from sd_hijack to separate v1/v2 embeddings
+        emb_type_a = sd_hijack.model_hijack.embedding_db.word_embeddings
+        emb_type_b = sd_hijack.model_hijack.embedding_db.skipped_embeddings
+        # Get the shape of the first item in the dict
+        emb_a_shape = -1
+        emb_b_shape = -1
+        if (len(emb_type_a) > 0):
+            emb_a_shape = next(iter(emb_type_a.items()))[1].shape
+        if (len(emb_type_b) > 0):
+            emb_b_shape = next(iter(emb_type_b.items()))[1].shape
+
+        # Add embeddings to the correct list
+        if (emb_a_shape == V1_SHAPE):
+            emb_v1 = list(emb_type_a.keys())
+        elif (emb_a_shape == V2_SHAPE):
+            emb_v2 = list(emb_type_a.keys())
+
+        if (emb_b_shape == V1_SHAPE):
+            emb_v1 = list(emb_type_b.keys())
+        elif (emb_b_shape == V2_SHAPE):
+            emb_v2 = list(emb_type_b.keys())
+
+        # Get shape of current model
+        #vec = sd_model.cond_stage_model.encode_embedding_init_text(",", 1)
+        #model_shape = vec.shape[1]
+        # Show relevant entries at the top
+        #if (model_shape == V1_SHAPE):
+        #    results = [e + ",v1" for e in emb_v1] + [e + ",v2" for e in emb_v2]
+        #elif (model_shape == V2_SHAPE):
+        #    results = [e + ",v2" for e in emb_v2] + [e + ",v1" for e in emb_v1]
+        #else:
+        #    raise AttributeError # Fallback to old method
+        results = sorted([e + ",v1" for e in emb_v1] + [e + ",v2" for e in emb_v2], key=lambda x: x.lower())
+    except AttributeError:
+        print("tag_autocomplete_helper: Old webui version or unrecognized model shape, using fallback for embedding completion.")
+        # Get a list of all embeddings in the folder
+        all_embeds = [str(e.relative_to(EMB_PATH)) for e in EMB_PATH.rglob("*") if e.suffix in {".bin", ".pt", ".png",'.webp', '.jxl', '.avif'}]
+        # Remove files with a size of 0
+        all_embeds = [e for e in all_embeds if EMB_PATH.joinpath(e).stat().st_size > 0]
+        # Remove file extensions
+        all_embeds = [e[:e.rfind('.')] for e in all_embeds]
+        results = [e + "," for e in all_embeds]
+
+    write_to_temp_file('emb.txt', results)
+
+def get_hypernetworks():
+    """Write a list of all hypernetworks"""
+
+    # Get a list of all hypernetworks in the folder
+    hyp_paths = [Path(h) for h in glob.glob(HYP_PATH.joinpath("**/*").as_posix(), recursive=True)]
+    all_hypernetworks = [str(h.name) for h in hyp_paths if h.suffix in {".pt"}]
+    # Remove file extensions
+    return sorted([h[:h.rfind('.')] for h in all_hypernetworks], key=lambda x: x.lower())
+
+def get_lora():
+    """Write a list of all lora"""
+
+    # Get a list of all lora in the folder
+    lora_paths = [Path(l) for l in glob.glob(LORA_PATH.joinpath("**/*").as_posix(), recursive=True)]
+    all_lora = [str(l.name) for l in lora_paths if l.suffix in {".safetensors", ".ckpt", ".pt"}]
+    # Remove file extensions
+    return sorted([l[:l.rfind('.')] for l in all_lora], key=lambda x: x.lower())
+
+def get_lyco():
+    """Write a list of all LyCORIS/LOHA from https://github.com/KohakuBlueleaf/a1111-sd-webui-lycoris"""
+
+    # Get a list of all LyCORIS in the folder
+    lyco_paths = [Path(ly) for ly in glob.glob(LYCO_PATH.joinpath("**/*").as_posix(), recursive=True)]
+    all_lyco = [str(ly.name) for ly in lyco_paths if ly.suffix in {".safetensors", ".ckpt", ".pt"}]
+    # Remove file extensions
+    return sorted([ly[:ly.rfind('.')] for ly in all_lyco], key=lambda x: x.lower())
+
+def write_tag_base_path():
+    """Writes the tag base path to a fixed location temporary file"""
+    with open(STATIC_TEMP_PATH.joinpath('tagAutocompletePath.txt'), 'w', encoding="utf-8") as f:
+        f.write(TAGS_PATH.relative_to(FILE_DIR).as_posix())
+
+
+def write_to_temp_file(name, data):
+    """Writes the given data to a temporary file"""
+    with open(TEMP_PATH.joinpath(name), 'w', encoding="utf-8") as f:
+        f.write(('\n'.join(data)))
+
+
+csv_files = []
+csv_files_withnone = []
+def update_tag_files():
+    """Returns a list of all potential tag files"""
+    global csv_files, csv_files_withnone
+    files = [str(t.relative_to(TAGS_PATH)) for t in TAGS_PATH.glob("*.csv")]
+    csv_files = files
+    csv_files_withnone = ["None"] + files
+
+
+
+# Write the tag base path to a fixed location temporary file
+# to enable the javascript side to find our files regardless of extension folder name
+if not STATIC_TEMP_PATH.exists():
+    STATIC_TEMP_PATH.mkdir(exist_ok=True)
+
+write_tag_base_path()
+update_tag_files()
+
+# Check if the temp path exists and create it if not
+if not TEMP_PATH.exists():
+    TEMP_PATH.mkdir(parents=True, exist_ok=True)
+
+# Set up files to ensure the script doesn't fail to load them
+# even if no wildcards or embeddings are found
+write_to_temp_file('wc.txt', [])
+write_to_temp_file('wce.txt', [])
+write_to_temp_file('wcet.txt', [])
+write_to_temp_file('hyp.txt', [])
+write_to_temp_file('lora.txt', [])
+write_to_temp_file('lyco.txt', [])
+# Only reload embeddings if the file doesn't exist, since they are already re-written on model load
+if not TEMP_PATH.joinpath("emb.txt").exists():
+    write_to_temp_file('emb.txt', [])
+
+# Write wildcards to wc.txt if found
+if WILDCARD_PATH.exists():
+    wildcards = [WILDCARD_PATH.relative_to(FILE_DIR).as_posix()] + get_wildcards()
+    if wildcards:
+        write_to_temp_file('wc.txt', wildcards)
+
+# Write extension wildcards to wce.txt if found
+if WILDCARD_EXT_PATHS is not None:
+    wildcards_ext = get_ext_wildcards()
+    if wildcards_ext:
+        write_to_temp_file('wce.txt', wildcards_ext)
+    # Write yaml extension wildcards to wcet.txt if found
+    wildcards_yaml_ext = get_ext_wildcard_tags()
+    if wildcards_yaml_ext:
+        write_to_temp_file('wcet.txt', wildcards_yaml_ext)
+
+# Write embeddings to emb.txt if found
+if EMB_PATH.exists():
+    # Get embeddings after the model loaded callback
+    script_callbacks.on_model_loaded(get_embeddings)
+
+if HYP_PATH.exists():
+    hypernets = get_hypernetworks()
+    if hypernets:
+        write_to_temp_file('hyp.txt', hypernets)
+
+if LORA_PATH is not None and LORA_PATH.exists():
+    lora = get_lora()
+    if lora:
+        write_to_temp_file('lora.txt', lora)
+
+if LYCO_PATH is not None and LYCO_PATH.exists():
+    lyco = get_lyco()
+    if lyco:
+        write_to_temp_file('lyco.txt', lyco)
+
+# Register autocomplete options
+def on_ui_settings():
+    TAC_SECTION = ("tac", "Tag Autocomplete")
+    # Main tag file
+    shared.opts.add_option("tac_tagFile", shared.OptionInfo("danbooru.csv", "Tag filename", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    # Active in settings
+    shared.opts.add_option("tac_active", shared.OptionInfo(True, "Enable Tag Autocompletion", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.txt2img", shared.OptionInfo(True, "Active in txt2img (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.img2img", shared.OptionInfo(True, "Active in img2img (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.negativePrompts", shared.OptionInfo(True, "Active in negative prompts (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.thirdParty", shared.OptionInfo(True, "Active in third party textboxes [Dataset Tag Editor] [Image Browser] [Tagger] [Multidiffusion Upscaler] (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.modelList", shared.OptionInfo("", "List of model names (with file extension) or their hashes to use as black/whitelist, separated by commas.", section=TAC_SECTION))
+    shared.opts.add_option("tac_activeIn.modelListMode", shared.OptionInfo("Blacklist", "Mode to use for model list", gr.Dropdown, lambda: {"choices": ["Blacklist","Whitelist"]}, section=TAC_SECTION))
+    # Results related settings
+    shared.opts.add_option("tac_slidingPopup", shared.OptionInfo(True, "Move completion popup together with text cursor", section=TAC_SECTION))
+    shared.opts.add_option("tac_maxResults", shared.OptionInfo(5, "Maximum results", section=TAC_SECTION))
+    shared.opts.add_option("tac_showAllResults", shared.OptionInfo(False, "Show all results", section=TAC_SECTION))
+    shared.opts.add_option("tac_resultStepLength", shared.OptionInfo(100, "How many results to load at once", section=TAC_SECTION))
+    shared.opts.add_option("tac_delayTime", shared.OptionInfo(100, "Time in ms to wait before triggering completion again (Requires restart)", section=TAC_SECTION))
+    shared.opts.add_option("tac_useWildcards", shared.OptionInfo(True, "Search for wildcards", section=TAC_SECTION))
+    shared.opts.add_option("tac_useEmbeddings", shared.OptionInfo(True, "Search for embeddings", section=TAC_SECTION))
+    shared.opts.add_option("tac_useHypernetworks", shared.OptionInfo(True, "Search for hypernetworks", section=TAC_SECTION))
+    shared.opts.add_option("tac_useLoras", shared.OptionInfo(True, "Search for Loras", section=TAC_SECTION))
+    shared.opts.add_option("tac_useLycos", shared.OptionInfo(True, "Search for LyCORIS/LoHa", section=TAC_SECTION))
+    shared.opts.add_option("tac_showWikiLinks", shared.OptionInfo(False, "Show '?' next to tags, linking to its Danbooru or e621 wiki page (Warning: This is an external site and very likely contains NSFW examples!)", section=TAC_SECTION))
+    # Insertion related settings
+    shared.opts.add_option("tac_replaceUnderscores", shared.OptionInfo(True, "Replace underscores with spaces on insertion", section=TAC_SECTION))
+    shared.opts.add_option("tac_escapeParentheses", shared.OptionInfo(True, "Escape parentheses on insertion", section=TAC_SECTION))
+    shared.opts.add_option("tac_appendComma", shared.OptionInfo(True, "Append comma on tag autocompletion", section=TAC_SECTION))
+    # Alias settings
+    shared.opts.add_option("tac_alias.searchByAlias", shared.OptionInfo(True, "Search by alias", section=TAC_SECTION))
+    shared.opts.add_option("tac_alias.onlyShowAlias", shared.OptionInfo(False, "Only show alias", section=TAC_SECTION))
+    # Translation settings
+    shared.opts.add_option("tac_translation.translationFile", shared.OptionInfo("None", "Translation filename", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    shared.opts.add_option("tac_translation.oldFormat", shared.OptionInfo(False, "Translation file uses old 3-column translation format instead of the new 2-column one", section=TAC_SECTION))
+    shared.opts.add_option("tac_translation.searchByTranslation", shared.OptionInfo(True, "Search by translation", section=TAC_SECTION))
+    # Extra file settings
+    shared.opts.add_option("tac_extra.extraFile", shared.OptionInfo("extra-quality-tags.csv", "Extra filename (for small sets of custom tags)", gr.Dropdown, lambda: {"choices": csv_files_withnone}, refresh=update_tag_files, section=TAC_SECTION))
+    shared.opts.add_option("tac_extra.addMode", shared.OptionInfo("Insert before", "Mode to add the extra tags to the main tag list", gr.Dropdown, lambda: {"choices": ["Insert before","Insert after"]}, section=TAC_SECTION))
+    # Custom mappings
+    keymapDefault = """\
+{
+    "MoveUp": "ArrowUp",
+    "MoveDown": "ArrowDown",
+    "JumpUp": "PageUp",
+    "JumpDown": "PageDown",
+    "JumpToStart": "Home",
+    "JumpToEnd": "End",
+    "ChooseSelected": "Enter",
+    "ChooseFirstOrSelected": "Tab",
+    "Close": "Escape"
+}\
+"""
+    colorDefault = """\
+{
+    "danbooru": {
+        "-1": ["red", "maroon"],
+        "0": ["lightblue", "dodgerblue"],
+        "1": ["indianred", "firebrick"],
+        "3": ["violet", "darkorchid"],
+        "4": ["lightgreen", "darkgreen"],
+        "5": ["orange", "darkorange"]
+    },
+    "e621": {
+        "-1": ["red", "maroon"],
+        "0": ["lightblue", "dodgerblue"],
+        "1": ["gold", "goldenrod"],
+        "3": ["violet", "darkorchid"],
+        "4": ["lightgreen", "darkgreen"],
+        "5": ["tomato", "darksalmon"],
+        "6": ["red", "maroon"],
+        "7": ["whitesmoke", "black"],
+        "8": ["seagreen", "darkseagreen"]
+    }
+}\
+"""
+    keymapLabel = "Configure Hotkeys. For possible values, see https://www.w3.org/TR/uievents-key, or leave empty / set to 'None' to disable. Must be valid JSON."
+    colorLabel = "Configure colors. See https://github.com/DominikDoom/a1111-sd-webui-tagcomplete#colors for info. Must be valid JSON."
+
+    try:
+        shared.opts.add_option("tac_keymap", shared.OptionInfo(keymapDefault, keymapLabel, gr.Code, lambda: {"language": "json", "interactive": True}, section=TAC_SECTION))
+        shared.opts.add_option("tac_colormap", shared.OptionInfo(colorDefault, colorLabel, gr.Code, lambda: {"language": "json", "interactive": True}, section=TAC_SECTION))
+    except AttributeError:
+        shared.opts.add_option("tac_keymap", shared.OptionInfo(keymapDefault, keymapLabel, gr.Textbox, section=TAC_SECTION))
+        shared.opts.add_option("tac_colormap", shared.OptionInfo(colorDefault, colorLabel, gr.Textbox, section=TAC_SECTION))
+
+
+script_callbacks.on_ui_settings(on_ui_settings)

a1111-microsoftexcel-tagcomplete/tags/extra-quality-tags.csv

@@ -0,0 +1,6 @@
+masterpiece,5,Quality tag,,
+best_quality,5,Quality tag,,
+high_quality,5,Quality tag,,
+normal_quality,5,Quality tag,,
+low_quality,5,Quality tag,,
+worst_quality,5,Quality tag,,

a1111-microsoftexcel-tagcomplete/tags/temp/emb.txt

@@ -0,0 +1,26 @@
+21charturnerv2,v2
+Asian-Less-Neg,v1
+bad-artist,v1
+bad-artist-anime,v1
+bad-hands-5,v1
+bad-image-v2-39000,v1
+bad-picture-chill-75v,v1
+bad_pictures,v1
+bad_prompt,v1
+bad_prompt_version2,v1
+badhandv4,v1
+charturnerv2,v1
+CyberRealistic_Negative-neg,v1
+easynegative,v1
+EasyNegativeV2,v1
+HyperStylizeV6,v1
+nartfixer,v2
+negative_hand-neg,v1
+nfixer,v2
+ng_deepnegative_v1_75t,v1
+nrealfixer,v2
+pureerosface_v1,v1
+rmadanegative402_sd15-neg,v1
+ulzzang-6500,v1
+ulzzang-6500-v1.1,v1
+verybadimagenegative_v1.3,v1

a1111-microsoftexcel-tagcomplete/tags/temp/lora.txt

@@ -0,0 +1 @@
+GoodHands-beta2

a1111-sd-webui-lycoris/.gitignore

@@ -0,0 +1 @@
+__pycache__

a1111-sd-webui-lycoris/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023] [KohakuBlueLeaf]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

a1111-sd-webui-lycoris/README.md

@@ -0,0 +1,53 @@
+# a1111-sd-webui-lycoris
+
+An extension for loading lycoris model in sd-webui. 
+I made this stand alone extension (Use sd-webui's extra networks api) to avoid some conflict with other loras extensions.
+
+## How to install
+There are some options you can choose to install this extension
+* Open the extension tab and go to "available" tab, search "lycoris" to find this extension and then install it.
+* Open the extension tab and go to "from url" tab, copy-paste the url of this repo (https://github.com/KohakuBlueleaf/a1111-sd-webui-lycoris) and click install.
+* Manually clone this repo to the extension folder or download the zip.
+
+## The version of stable-diffusion-webui
+Lot of people struggling on some bugs or unexpected behavior after install the extension. We do some research and test on it and can only get this conclusion:<br>
+**Make sure your stable diffusion webui is after commit: a9fed7c3** <br>
+(a9fed7c3 itself should work, but if you meet problem on that commit, you should consider to update your sd-webui)
+
+### LyCORIS
+https://github.com/KohakuBlueleaf/LyCORIS
+
+### usage
+Install it and restart the webui 
+**Don't use "Apply and restart UI", please restart the webui process**
+
+And you will find "LyCORIS" tab in the extra networks page
+Use `<lyco:MODEL:WEIGHT>` to utilize the lycoris model
+![image](https://user-images.githubusercontent.com/59680068/230762416-be1d3712-65f2-4dd1-ac7a-f403c914dd9b.png)
+
+The launch parameter `--lyco-dir` can be used to define LyCORIS models location path
+
+## Arguments
+sd-webui use this format to use extra networks: `<TYPE:MODEL_NAME:arg1:arg2:arg3...:argn>`<br>
+With more and more different algorithm be implemented into lycoris, the arguments become more.<br>
+So I design this arg system to use it more easily(Maybe):<br>
+<br>
+`<lyco:MODEL:arg1:arg2:k1=v1:k2=v2>`<br>
+<br>
+For example, we have te/unet/dyn these 3 arguments, if you want te=1, unet=0.5, dyn=13, you can use it like these:<br>
+`<lyco:Model:1:0.5:13>`<br>
+`<lyco:Model:1:0.5:dyn=13>`<br>
+`<lyco:Model:1:unet=0.5:dyn=13>`<br>
+And if you specify ALL the key name, you can ignore the order:<br>
+(or, actually, we only count the args, no k-v pair, so dyn=13:unet=1:0.5 also work, but 0.5 is for te (the first argument))<br>
+`<lyco:Model:dyn=13:te=1:unet=0.5>`<br>
+<br>
+And since te=1 is default value, you can also do it like this:<br>
+`<lyco:Model:unet=0.5:dyn=13>`<br>
+
+And here is the list for arguments:
+| Argument    | What it does| default type and value|
+| ----------- | ----------- | ----------- |
+| te          | the weight for text encoder | `float: 1.0`|
+| unet   | the weight for UNet, when it is None, it use same value as te | `float: None`|
+| dyn | How many row you want to utilize when using dylora, if you set to 0, it will disable the dylora| `int: None` |

a1111-sd-webui-lycoris/extra_networks_lyco.py

@@ -0,0 +1,95 @@
+from modules import extra_networks, shared
+import lycoris
+
+
+default_args = [
+    ('te', 1.0, float),
+    ('unet', None, float),
+    ('dyn', None, int)
+]
+
+
+def parse_args(params:list):
+    arg_list = []
+    kwarg_list = {}
+    
+    for i in params:
+        if '=' in str(i):
+            k, v = i.split('=', 1)
+            kwarg_list[k] = v
+        else:
+            arg_list.append(i)
+    
+    args = []
+    for name, default, type in default_args:
+        if name in kwarg_list:
+            x = kwarg_list[name]
+        elif arg_list:
+            x = arg_list.pop(0)
+        else:
+            x = default
+        
+        if x == 'default':
+            x = default
+        elif x is not None:
+            x = type(x)
+        
+        args.append(x)
+    
+    return args
+
+
+class ExtraNetworkLyCORIS(extra_networks.ExtraNetwork):
+    def __init__(self):
+        super().__init__('lyco')
+        self.cache = ()
+
+    def activate(self, p, params_list):
+        additional = shared.opts.sd_lyco
+
+        if additional != "" and additional in lycoris.available_lycos and len([x for x in params_list if x.items[0] == additional]) == 0:
+            p.all_prompts = [
+                x + 
+                f"<lyco:{additional}:{shared.opts.extra_networks_default_multiplier}>" 
+                for x in p.all_prompts
+            ]
+            params_list.append(
+                extra_networks.ExtraNetworkParams(
+                    items=[additional, shared.opts.extra_networks_default_multiplier])
+                )
+
+        names = []
+        te_multipliers = []
+        unet_multipliers = []
+        dyn_dims = []
+        for params in params_list:
+            assert len(params.items) > 0
+
+            names.append(params.items[0])
+            te, unet, dyn_dim = parse_args(params.items[1:])
+            if unet is None:
+                unet = te
+            te_multipliers.append(te)
+            unet_multipliers.append(unet)
+            dyn_dims.append(dyn_dim)
+        
+        all_lycos = tuple(
+            (name, te, unet, dyn)
+            for name, te, unet, dyn in zip(names, te_multipliers, unet_multipliers, dyn_dims)
+        )
+        
+        if all_lycos != self.cache:
+            for name, te, unet, dyn in all_lycos:
+                print(
+                    "========================================\n"
+                    f"Apply LyCORIS model: {name}\n"
+                    f"Text encoder weight: {te}\n"
+                    f"Unet weight: {unet}\n"
+                    f"DyLoRA Dim: {dyn}"
+                )
+            print("========================================")
+            self.cache = all_lycos
+        lycoris.load_lycos(names, te_multipliers, unet_multipliers, dyn_dims)
+
+    def deactivate(self, p):
+        pass

a1111-sd-webui-lycoris/lycoris.py

@@ -0,0 +1,793 @@
+from typing import *
+import os, sys
+import re
+import glob
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from modules import shared, devices, sd_models, errors
+
+metadata_tags_order = {"ss_sd_model_name": 1, "ss_resolution": 2, "ss_clip_skip": 3, "ss_num_train_images": 10, "ss_tag_frequency": 20}
+
+
+re_digits = re.compile(r"\d+")
+re_x_proj = re.compile(r"(.*)_([qkv]_proj)$")
+
+re_unet_conv_in = re.compile(r"lora_unet_conv_in(.+)")
+re_unet_conv_out = re.compile(r"lora_unet_conv_out(.+)")
+re_unet_time_embed = re.compile(r"lora_unet_time_embedding_linear_(\d+)(.+)")
+
+re_unet_down_blocks = re.compile(r"lora_unet_down_blocks_(\d+)_attentions_(\d+)_(.+)")
+re_unet_mid_blocks = re.compile(r"lora_unet_mid_block_attentions_(\d+)_(.+)")
+re_unet_up_blocks = re.compile(r"lora_unet_up_blocks_(\d+)_attentions_(\d+)_(.+)")
+
+re_unet_down_blocks_res = re.compile(r"lora_unet_down_blocks_(\d+)_resnets_(\d+)_(.+)")
+re_unet_mid_blocks_res = re.compile(r"lora_unet_mid_block_resnets_(\d+)_(.+)")
+re_unet_up_blocks_res = re.compile(r"lora_unet_up_blocks_(\d+)_resnets_(\d+)_(.+)")
+
+re_unet_downsample = re.compile(r"lora_unet_down_blocks_(\d+)_downsamplers_0_conv(.+)")
+re_unet_upsample = re.compile(r"lora_unet_up_blocks_(\d+)_upsamplers_0_conv(.+)")
+
+re_text_block = re.compile(r"lora_te_text_model_encoder_layers_(\d+)_(.+)")
+
+
+def convert_diffusers_name_to_compvis(key, is_sd2):
+    # I don't know why but some state dict has this kind of thing
+    key = key.replace('text_model_text_model', 'text_model')
+    def match(match_list, regex):
+        r = re.match(regex, key)
+        if not r:
+            return False
+
+        match_list.clear()
+        match_list.extend([int(x) if re.match(re_digits, x) else x for x in r.groups()])
+        return True
+
+    m = []
+    
+    if match(m, re_unet_conv_in):
+        return f'diffusion_model_input_blocks_0_0{m[0]}'
+    
+    if match(m, re_unet_conv_out):
+        return f'diffusion_model_out_2{m[0]}'
+    
+    if match(m, re_unet_time_embed):
+        return f"diffusion_model_time_embed_{m[0]*2-2}{m[1]}"
+    
+    if match(m, re_unet_down_blocks):
+        return f"diffusion_model_input_blocks_{1 + m[0] * 3 + m[1]}_1_{m[2]}"
+
+    if match(m, re_unet_mid_blocks):
+        return f"diffusion_model_middle_block_1_{m[1]}"
+
+    if match(m, re_unet_up_blocks):
+        return f"diffusion_model_output_blocks_{m[0] * 3 + m[1]}_1_{m[2]}"
+
+    if match(m, re_unet_down_blocks_res):
+        block = f"diffusion_model_input_blocks_{1 + m[0] * 3 + m[1]}_0_"
+        if m[2].startswith('conv1'):
+            return f"{block}in_layers_2{m[2][len('conv1'):]}"
+        elif m[2].startswith('conv2'):
+            return f"{block}out_layers_3{m[2][len('conv2'):]}"
+        elif m[2].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[2][len('time_emb_proj'):]}"
+        elif m[2].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[2][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_mid_blocks_res):
+        block = f"diffusion_model_middle_block_{m[0]*2}_"
+        if m[1].startswith('conv1'):
+            return f"{block}in_layers_2{m[1][len('conv1'):]}"
+        elif m[1].startswith('conv2'):
+            return f"{block}out_layers_3{m[1][len('conv2'):]}"
+        elif m[1].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[1][len('time_emb_proj'):]}"
+        elif m[1].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[1][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_up_blocks_res):
+        block = f"diffusion_model_output_blocks_{m[0] * 3 + m[1]}_0_"
+        if m[2].startswith('conv1'):
+            return f"{block}in_layers_2{m[2][len('conv1'):]}"
+        elif m[2].startswith('conv2'):
+            return f"{block}out_layers_3{m[2][len('conv2'):]}"
+        elif m[2].startswith('time_emb_proj'):
+            return f"{block}emb_layers_1{m[2][len('time_emb_proj'):]}"
+        elif m[2].startswith('conv_shortcut'):
+            return f"{block}skip_connection{m[2][len('conv_shortcut'):]}"
+
+    if match(m, re_unet_downsample):
+        return f"diffusion_model_input_blocks_{m[0]*3+3}_0_op{m[1]}"
+
+    if match(m, re_unet_upsample):
+        return f"diffusion_model_output_blocks_{m[0]*3 + 2}_{1+(m[0]!=0)}_conv{m[1]}"
+
+    if match(m, r"lora_te_text_model_encoder_layers_(\d+)_(.+)"):
+        if is_sd2:
+            if 'mlp_fc1' in m[1]:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('mlp_fc1', 'mlp_c_fc')}"
+            elif 'mlp_fc2' in m[1]:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('mlp_fc2', 'mlp_c_proj')}"
+            else:
+                return f"model_transformer_resblocks_{m[0]}_{m[1].replace('self_attn', 'attn')}"
+
+        return f"transformer_text_model_encoder_layers_{m[0]}_{m[1]}"
+
+    return key
+
+
+def assign_lyco_names_to_compvis_modules(sd_model):
+    lyco_layer_mapping = {}
+
+    for name, module in shared.sd_model.cond_stage_model.wrapped.named_modules():
+        lyco_name = name.replace(".", "_")
+        lyco_layer_mapping[lyco_name] = module
+        module.lyco_layer_name = lyco_name
+
+    for name, module in shared.sd_model.model.named_modules():
+        lyco_name = name.replace(".", "_")
+        lyco_layer_mapping[lyco_name] = module
+        module.lyco_layer_name = lyco_name
+
+    sd_model.lyco_layer_mapping = lyco_layer_mapping
+
+
+class LycoOnDisk:
+    def __init__(self, name, filename):
+        self.name = name
+        self.filename = filename
+        self.metadata = {}
+
+        _, ext = os.path.splitext(filename)
+        if ext.lower() == ".safetensors":
+            try:
+                self.metadata = sd_models.read_metadata_from_safetensors(filename)
+            except Exception as e:
+                errors.display(e, f"reading lora {filename}")
+
+        if self.metadata:
+            m = {}
+            for k, v in sorted(self.metadata.items(), key=lambda x: metadata_tags_order.get(x[0], 999)):
+                m[k] = v
+
+            self.metadata = m
+
+        self.ssmd_cover_images = self.metadata.pop('ssmd_cover_images', None)  # those are cover images and they are too big to display in UI as text
+
+
+class LycoModule:
+    def __init__(self, name):
+        self.name = name
+        self.te_multiplier = 1.0
+        self.unet_multiplier = 1.0
+        self.dyn_dim = None
+        self.modules = {}
+        self.mtime = None
+
+
+class FullModule:
+    def __init__(self):
+        self.weight = None
+        self.alpha = None
+        self.scale = None
+        self.dim = None
+        self.shape = None
+
+
+class LycoUpDownModule:
+    def __init__(self):
+        self.up_model = None
+        self.mid_model = None
+        self.down_model = None
+        self.alpha = None
+        self.scale = None
+        self.dim = None
+        self.shape = None
+        self.bias = None
+
+
+def make_weight_cp(t, wa, wb):
+    temp = torch.einsum('i j k l, j r -> i r k l', t, wb)
+    return torch.einsum('i j k l, i r -> r j k l', temp, wa)
+
+
+class LycoHadaModule:
+    def __init__(self):
+        self.t1 = None
+        self.w1a = None
+        self.w1b = None
+        self.t2 = None
+        self.w2a = None
+        self.w2b = None
+        self.alpha = None
+        self.scale = None
+        self.dim = None
+        self.shape = None
+        self.bias = None
+
+
+class IA3Module:
+    def __init__(self):
+        self.w = None
+        self.alpha = None
+        self.scale = None
+        self.dim = None
+        self.on_input = None
+
+
+def make_kron(orig_shape, w1, w2):
+    if len(w2.shape) == 4:
+        w1 = w1.unsqueeze(2).unsqueeze(2)
+    w2 = w2.contiguous()
+    return torch.kron(w1, w2).reshape(orig_shape)
+
+
+class LycoKronModule:
+    def __init__(self):
+        self.w1 = None
+        self.w1a = None
+        self.w1b = None
+        self.w2 = None
+        self.t2 = None
+        self.w2a = None
+        self.w2b = None
+        self._alpha = None
+        self.scale = None
+        self.dim = None
+        self.shape = None
+        self.bias = None
+    
+    @property
+    def alpha(self):
+        if self.w1a is None and self.w2a is None:
+            return None
+        else:
+            return self._alpha
+    
+    @alpha.setter
+    def alpha(self, x):
+        self._alpha = x
+
+
+CON_KEY = {
+    "lora_up.weight", "dyn_up",
+    "lora_down.weight", "dyn_down",
+    "lora_mid.weight"
+}
+HADA_KEY = {
+    "hada_t1",
+    "hada_w1_a",
+    "hada_w1_b",
+    "hada_t2",
+    "hada_w2_a",
+    "hada_w2_b",
+}
+IA3_KEY = {
+    "weight",
+    "on_input"
+}
+KRON_KEY = {
+    "lokr_w1",
+    "lokr_w1_a",
+    "lokr_w1_b",
+    "lokr_t2",
+    "lokr_w2",
+    "lokr_w2_a",
+    "lokr_w2_b",
+}
+
+def load_lyco(name, filename):
+    lyco = LycoModule(name)
+    lyco.mtime = os.path.getmtime(filename)
+
+    sd = sd_models.read_state_dict(filename)
+    is_sd2 = 'model_transformer_resblocks' in shared.sd_model.lyco_layer_mapping
+
+    keys_failed_to_match = []
+
+    for key_diffusers, weight in sd.items():
+        fullkey = convert_diffusers_name_to_compvis(key_diffusers, is_sd2)
+        key, lyco_key = fullkey.split(".", 1)
+        
+        sd_module = shared.sd_model.lyco_layer_mapping.get(key, None)
+        
+        if sd_module is None:
+            m = re_x_proj.match(key)
+            if m:
+                sd_module = shared.sd_model.lyco_layer_mapping.get(m.group(1), None)
+        
+        if sd_module is None:
+            print(key)
+            keys_failed_to_match.append(key_diffusers)
+            continue
+
+        lyco_module = lyco.modules.get(key, None)
+        if lyco_module is None:
+            lyco_module = LycoUpDownModule()
+            lyco.modules[key] = lyco_module
+
+        if lyco_key == "alpha":
+            lyco_module.alpha = weight.item()
+            continue
+        
+        if lyco_key == "scale":
+            lyco_module.scale = weight.item()
+            continue
+        
+        if lyco_key == "diff":
+            weight = weight.to(device=devices.cpu, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            lyco_module = FullModule()
+            lyco.modules[key] = lyco_module
+            lyco_module.weight = weight
+            continue
+        
+        if 'bias_' in lyco_key:
+            if lyco_module.bias is None:
+                lyco_module.bias = [None, None, None]
+            if 'bias_indices' == lyco_key:
+                lyco_module.bias[0] = weight
+            elif 'bias_values' == lyco_key:
+                lyco_module.bias[1] = weight
+            elif 'bias_size' == lyco_key:
+                lyco_module.bias[2] = weight
+            
+            if all((i is not None) for i in lyco_module.bias):
+                print('build bias')
+                lyco_module.bias = torch.sparse_coo_tensor(
+                    lyco_module.bias[0],
+                    lyco_module.bias[1],
+                    tuple(lyco_module.bias[2]),
+                ).to(device=devices.cpu, dtype=devices.dtype)
+                lyco_module.bias.requires_grad_(False)
+            continue
+        
+        if lyco_key in CON_KEY:
+            if (type(sd_module) == torch.nn.Linear
+                or type(sd_module) == torch.nn.modules.linear.NonDynamicallyQuantizableLinear
+                or type(sd_module) == torch.nn.MultiheadAttention):
+                weight = weight.reshape(weight.shape[0], -1)
+                module = torch.nn.Linear(weight.shape[1], weight.shape[0], bias=False)
+            elif type(sd_module) == torch.nn.Conv2d:
+                if lyco_key == "lora_down.weight" or lyco_key == "dyn_up":
+                    if len(weight.shape) == 2:
+                        weight = weight.reshape(weight.shape[0], -1, 1, 1)
+                    if weight.shape[2] != 1 or weight.shape[3] != 1:
+                        module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], sd_module.kernel_size, sd_module.stride, sd_module.padding, bias=False)
+                    else:
+                        module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], (1, 1), bias=False)
+                elif lyco_key == "lora_mid.weight":
+                    module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], sd_module.kernel_size, sd_module.stride, sd_module.padding, bias=False)
+                elif lyco_key == "lora_up.weight" or lyco_key == "dyn_down":
+                    module = torch.nn.Conv2d(weight.shape[1], weight.shape[0], (1, 1), bias=False)
+            else:
+                assert False, f'Lyco layer {key_diffusers} matched a layer with unsupported type: {type(sd_module).__name__}'
+            
+            if hasattr(sd_module, 'weight'):
+                lyco_module.shape = sd_module.weight.shape
+            with torch.no_grad():
+                if weight.shape != module.weight.shape:
+                    weight = weight.reshape(module.weight.shape)
+                module.weight.copy_(weight)
+
+            module.to(device=devices.cpu, dtype=devices.dtype)
+            module.requires_grad_(False)
+
+            if lyco_key == "lora_up.weight" or lyco_key == "dyn_up":
+                lyco_module.up_model = module
+            elif lyco_key == "lora_mid.weight":
+                lyco_module.mid_model = module
+            elif lyco_key == "lora_down.weight" or lyco_key == "dyn_down":
+                lyco_module.down_model = module
+                lyco_module.dim = weight.shape[0]
+            else:
+                print(lyco_key)
+        elif lyco_key in HADA_KEY:
+            if type(lyco_module) != LycoHadaModule:
+                alpha = lyco_module.alpha
+                bias = lyco_module.bias
+                lyco_module = LycoHadaModule()
+                lyco_module.alpha = alpha
+                lyco_module.bias = bias
+                lyco.modules[key] = lyco_module
+            if hasattr(sd_module, 'weight'):
+                lyco_module.shape = sd_module.weight.shape
+            
+            weight = weight.to(device=devices.cpu, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            
+            if lyco_key == 'hada_w1_a':
+                lyco_module.w1a = weight
+            elif lyco_key == 'hada_w1_b':
+                lyco_module.w1b = weight
+                lyco_module.dim = weight.shape[0]
+            elif lyco_key == 'hada_w2_a':
+                lyco_module.w2a = weight
+            elif lyco_key == 'hada_w2_b':
+                lyco_module.w2b = weight
+                lyco_module.dim = weight.shape[0]
+            elif lyco_key == 'hada_t1':
+                lyco_module.t1 = weight
+            elif lyco_key == 'hada_t2':
+                lyco_module.t2 = weight
+            
+        elif lyco_key in IA3_KEY:
+            if type(lyco_module) != IA3Module:
+                lyco_module = IA3Module()
+                lyco.modules[key] = lyco_module
+            
+            if lyco_key == "weight":
+                lyco_module.w = weight.to(devices.device, dtype=devices.dtype)
+            elif lyco_key == "on_input":
+                lyco_module.on_input = weight
+        elif lyco_key in KRON_KEY:
+            if not isinstance(lyco_module, LycoKronModule):
+                alpha = lyco_module.alpha
+                bias = lyco_module.bias
+                lyco_module = LycoKronModule()
+                lyco_module.alpha = alpha
+                lyco_module.bias = bias
+                lyco.modules[key] = lyco_module
+            if hasattr(sd_module, 'weight'):
+                lyco_module.shape = sd_module.weight.shape
+            
+            weight = weight.to(device=devices.cpu, dtype=devices.dtype)
+            weight.requires_grad_(False)
+            
+            if lyco_key == 'lokr_w1':
+                lyco_module.w1 = weight
+            elif lyco_key == 'lokr_w1_a':
+                lyco_module.w1a = weight
+            elif lyco_key == 'lokr_w1_b':
+                lyco_module.w1b = weight
+                lyco_module.dim = weight.shape[0]
+            elif lyco_key == 'lokr_w2':
+                lyco_module.w2 = weight
+            elif lyco_key == 'lokr_w2_a':
+                lyco_module.w2a = weight
+            elif lyco_key == 'lokr_w2_b':
+                lyco_module.w2b = weight
+                lyco_module.dim = weight.shape[0]
+            elif lyco_key == 'lokr_t2':
+                lyco_module.t2 = weight
+        else:
+            assert False, f'Bad Lyco layer name: {key_diffusers} - must end in lyco_up.weight, lyco_down.weight or alpha'
+
+    if len(keys_failed_to_match) > 0:
+        print(shared.sd_model.lyco_layer_mapping)
+        print(f"Failed to match keys when loading Lyco {filename}: {keys_failed_to_match}")
+
+    return lyco
+
+
+def load_lycos(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
+    already_loaded = {}
+
+    for lyco in loaded_lycos:
+        if lyco.name in names:
+            already_loaded[lyco.name] = lyco
+
+    loaded_lycos.clear()
+
+    lycos_on_disk = [available_lycos.get(name, None) for name in names]
+    if any([x is None for x in lycos_on_disk]):
+        list_available_lycos()
+
+        lycos_on_disk = [available_lycos.get(name, None) for name in names]
+
+    for i, name in enumerate(names):
+        lyco = already_loaded.get(name, None)
+
+        lyco_on_disk = lycos_on_disk[i]
+        if lyco_on_disk is not None:
+            if lyco is None or os.path.getmtime(lyco_on_disk.filename) > lyco.mtime:
+                lyco = load_lyco(name, lyco_on_disk.filename)
+
+        if lyco is None:
+            print(f"Couldn't find Lora with name {name}")
+            continue
+
+        lyco.te_multiplier = te_multipliers[i] if te_multipliers else 1.0
+        lyco.unet_multiplier = unet_multipliers[i] if unet_multipliers else lyco.te_multiplier
+        lyco.dyn_dim = dyn_dims[i] if dyn_dims else None
+        loaded_lycos.append(lyco)
+
+
+def _rebuild_conventional(up, down, shape, dyn_dim=None):
+    up = up.reshape(up.size(0), -1)
+    down = down.reshape(down.size(0), -1)
+    if dyn_dim is not None:
+        up = up[:, :dyn_dim]
+        down = down[:dyn_dim, :]
+    return (up @ down).reshape(shape)
+
+
+def _rebuild_cp_decomposition(up, down, mid):
+    up = up.reshape(up.size(0), -1)
+    down = down.reshape(down.size(0), -1)
+    return torch.einsum('n m k l, i n, m j -> i j k l', mid, up, down)
+
+
+def rebuild_weight(module, orig_weight: torch.Tensor, dyn_dim: int=None) -> torch.Tensor:
+    output_shape: Sized
+    if module.__class__.__name__ == 'LycoUpDownModule':
+        up = module.up_model.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+        down = module.down_model.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+        
+        output_shape = [up.size(0), down.size(1)]
+        if (mid:=module.mid_model) is not None:
+            # cp-decomposition
+            mid = mid.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown = _rebuild_cp_decomposition(up, down, mid)
+            output_shape += mid.shape[2:]
+        else:
+            if len(down.shape) == 4:
+                output_shape += down.shape[2:]
+            updown = _rebuild_conventional(up, down, output_shape, dyn_dim)
+        
+    elif module.__class__.__name__ == 'LycoHadaModule':
+        w1a = module.w1a.to(orig_weight.device, dtype=orig_weight.dtype)
+        w1b = module.w1b.to(orig_weight.device, dtype=orig_weight.dtype)
+        w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+        w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+        
+        output_shape = [w1a.size(0), w1b.size(1)]
+        
+        if module.t1 is not None:
+            output_shape = [w1a.size(1), w1b.size(1)]
+            t1 = module.t1.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown1 = make_weight_cp(t1, w1a, w1b)
+            output_shape += t1.shape[2:]
+        else:
+            if len(w1b.shape) == 4:
+                output_shape += w1b.shape[2:]
+            updown1 = _rebuild_conventional(w1a, w1b, output_shape)
+        
+        if module.t2 is not None:
+            t2 = module.t2.to(orig_weight.device, dtype=orig_weight.dtype)
+            updown2 = make_weight_cp(t2, w2a, w2b)
+        else:
+            updown2 = _rebuild_conventional(w2a, w2b, output_shape)
+        
+        updown = updown1 * updown2
+    
+    elif module.__class__.__name__ == 'FullModule':
+        output_shape = module.weight.shape
+        updown = module.weight.to(orig_weight.device, dtype=orig_weight.dtype)
+    
+    elif module.__class__.__name__ == 'IA3Module':
+        output_shape = [module.w.size(0), orig_weight.size(1)]
+        if module.on_input:
+            output_shape.reverse()
+        else:
+            module.w = module.w.reshape(-1, 1)
+        updown = orig_weight * module.w
+        
+    elif module.__class__.__name__ == 'LycoKronModule':
+        if module.w1 is not None:
+            w1 = module.w1.to(orig_weight.device, dtype=orig_weight.dtype)
+        else:
+            w1a = module.w1a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w1b = module.w1b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w1 = w1a @ w1b
+        
+        if module.w2 is not None:
+            w2 = module.w2.to(orig_weight.device, dtype=orig_weight.dtype)
+        elif module.t2 is None:
+            w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2 = w2a @ w2b
+        else:
+            t2 = module.t2.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2a = module.w2a.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2b = module.w2b.to(orig_weight.device, dtype=orig_weight.dtype)
+            w2 = make_weight_cp(t2, w2a, w2b)
+        
+        output_shape = [w1.size(0)*w2.size(0), w1.size(1)*w2.size(1)]
+        if len(orig_weight.shape) == 4:
+            output_shape = orig_weight.shape
+        
+        updown = make_kron(
+            output_shape, w1, w2
+        )
+    
+    else:
+        raise NotImplementedError(
+            f"Unknown module type: {module.__class__.__name__}\n"
+            "If the type is one of "
+            "'LycoUpDownModule', 'LycoHadaModule', 'FullModule', 'IA3Module', 'LycoKronModule'"
+            "You may have other lyco extension that conflict with locon extension."
+        )
+    
+    if hasattr(module, 'bias') and module.bias != None:
+        updown = updown.reshape(module.bias.shape)
+        updown += module.bias.to(orig_weight.device, dtype=orig_weight.dtype)
+        updown = updown.reshape(output_shape)
+    
+    if len(output_shape) == 4:
+        updown = updown.reshape(output_shape)
+    
+    if orig_weight.size().numel() == updown.size().numel():
+        updown = updown.reshape(orig_weight.shape)
+    # print(torch.sum(updown))
+    return updown
+
+
+def lyco_calc_updown(lyco, module, target):
+    with torch.no_grad():
+        updown = rebuild_weight(module, target, lyco.dyn_dim)
+        if lyco.dyn_dim and module.dim:
+            dim = min(lyco.dyn_dim, module.dim)
+        elif lyco.dyn_dim:
+            dim = lyco.dyn_dim
+        elif module.dim:
+            dim = module.dim
+        else:
+            dim = None
+        scale = (
+            module.scale if module.scale is not None
+            else module.alpha / dim if dim is not None and module.alpha is not None
+            else 1.0
+        )
+        # print(scale, module.alpha, module.dim, lyco.dyn_dim)
+        updown = updown * scale
+        return updown
+
+
+def lyco_apply_weights(self: Union[torch.nn.Conv2d, torch.nn.Linear, torch.nn.MultiheadAttention]):
+    """
+    Applies the currently selected set of Lycos to the weights of torch layer self.
+    If weights already have this particular set of lycos applied, does nothing.
+    If not, restores orginal weights from backup and alters weights according to lycos.
+    """
+    
+    lyco_layer_name = getattr(self, 'lyco_layer_name', None)
+    if lyco_layer_name is None:
+        return
+
+    current_names = getattr(self, "lyco_current_names", ())
+    lora_prev_names = getattr(self, "lora_prev_names", ())
+    lora_names = getattr(self, "lora_current_names", ())
+    wanted_names = tuple((x.name, x.te_multiplier, x.unet_multiplier, x.dyn_dim) for x in loaded_lycos)
+
+    weights_backup = getattr(self, "lyco_weights_backup", None)
+    lora_weights_backup = getattr(self, "lora_weights_backup", None)
+    if weights_backup is None and len(loaded_lycos):
+        # print('lyco save weight')
+        if isinstance(self, torch.nn.MultiheadAttention):
+            weights_backup = (
+                self.in_proj_weight.to(devices.cpu, copy=True), 
+                self.out_proj.weight.to(devices.cpu, copy=True)
+            )
+        else:
+            weights_backup = self.weight.to(devices.cpu, copy=True)
+        self.lyco_weights_backup = weights_backup
+    elif lora_prev_names != lora_names:
+        # print('lyco remove weight')
+        self.lyco_weights_backup = None
+        lora_weights_backup = None
+    elif len(loaded_lycos) == 0:
+        self.lyco_weights_backup = None
+
+    if current_names != wanted_names or lora_prev_names != lora_names:
+        if weights_backup is not None and lora_names == lora_prev_names:
+            # print('lyco restore weight')
+            if isinstance(self, torch.nn.MultiheadAttention):
+                self.in_proj_weight.copy_(weights_backup[0])
+                self.out_proj.weight.copy_(weights_backup[1])
+            else:
+                self.weight.copy_(weights_backup)
+        elif lora_weights_backup is not None and lora_names == ():
+            # print('lora restore weight')
+            if isinstance(self, torch.nn.MultiheadAttention):
+                self.in_proj_weight.copy_(lora_weights_backup[0])
+                self.out_proj.weight.copy_(lora_weights_backup[1])
+            else:
+                self.weight.copy_(lora_weights_backup)
+
+        for lyco in loaded_lycos:
+            module = lyco.modules.get(lyco_layer_name, None)
+            multiplier = (
+                lyco.te_multiplier if 'transformer' in lyco_layer_name[:20] 
+                else lyco.unet_multiplier
+            )
+            if module is not None and hasattr(self, 'weight'):
+                # print(lyco_layer_name, multiplier)
+                updown = lyco_calc_updown(lyco, module, self.weight)
+                if len(self.weight.shape) == 4 and self.weight.shape[1] == 9:
+                    # inpainting model. zero pad updown to make channel[1]  4 to 9
+                    updown = F.pad(updown, (0, 0, 0, 0, 0, 5))
+                self.weight += updown * multiplier
+                continue
+
+            module_q = lyco.modules.get(lyco_layer_name + "_q_proj", None)
+            module_k = lyco.modules.get(lyco_layer_name + "_k_proj", None)
+            module_v = lyco.modules.get(lyco_layer_name + "_v_proj", None)
+            module_out = lyco.modules.get(lyco_layer_name + "_out_proj", None)
+
+            if isinstance(self, torch.nn.MultiheadAttention) and module_q and module_k and module_v and module_out:
+                updown_q = lyco_calc_updown(lyco, module_q, self.in_proj_weight)
+                updown_k = lyco_calc_updown(lyco, module_k, self.in_proj_weight)
+                updown_v = lyco_calc_updown(lyco, module_v, self.in_proj_weight)
+                updown_qkv = torch.vstack([updown_q, updown_k, updown_v])
+
+                self.in_proj_weight += updown_qkv
+                self.out_proj.weight += lyco_calc_updown(lyco, module_out, self.out_proj.weight)
+                continue
+
+            if module is None:
+                continue
+
+            print(3, f'failed to calculate lyco weights for layer {lyco_layer_name}')
+            # print(lyco_his, lyco.name not in lyco_his)
+
+        setattr(self, "lora_prev_names", lora_names)
+        setattr(self, "lyco_current_names", wanted_names)
+
+
+def lyco_reset_cached_weight(self: Union[torch.nn.Conv2d, torch.nn.Linear]):
+    setattr(self, "lyco_current_names", ())
+    setattr(self, "lyco_weights_backup", None)
+
+
+def lyco_Linear_forward(self, input):
+    lyco_apply_weights(self)
+
+    return torch.nn.Linear_forward_before_lyco(self, input)
+
+
+def lyco_Linear_load_state_dict(self, *args, **kwargs):
+    lyco_reset_cached_weight(self)
+
+    return torch.nn.Linear_load_state_dict_before_lyco(self, *args, **kwargs)
+
+
+def lyco_Conv2d_forward(self, input):
+    lyco_apply_weights(self)
+
+    return torch.nn.Conv2d_forward_before_lyco(self, input)
+
+
+def lyco_Conv2d_load_state_dict(self, *args, **kwargs):
+    lyco_reset_cached_weight(self)
+
+    return torch.nn.Conv2d_load_state_dict_before_lyco(self, *args, **kwargs)
+
+
+def lyco_MultiheadAttention_forward(self, *args, **kwargs):
+    lyco_apply_weights(self)
+
+    return torch.nn.MultiheadAttention_forward_before_lyco(self, *args, **kwargs)
+
+
+def lyco_MultiheadAttention_load_state_dict(self, *args, **kwargs):
+    lyco_reset_cached_weight(self)
+
+    return torch.nn.MultiheadAttention_load_state_dict_before_lyco(self, *args, **kwargs)
+
+
+def list_available_lycos():
+    available_lycos.clear()
+
+    os.makedirs(shared.cmd_opts.lyco_dir, exist_ok=True)
+
+    candidates = \
+        glob.glob(os.path.join(shared.cmd_opts.lyco_dir, '**/*.pt'), recursive=True) + \
+        glob.glob(os.path.join(shared.cmd_opts.lyco_dir, '**/*.safetensors'), recursive=True) + \
+        glob.glob(os.path.join(shared.cmd_opts.lyco_dir, '**/*.ckpt'), recursive=True)
+
+    for filename in sorted(candidates, key=str.lower):
+        if os.path.isdir(filename):
+            continue
+
+        name = os.path.splitext(os.path.basename(filename))[0]
+
+        available_lycos[name] = LycoOnDisk(name, filename)
+
+
+available_lycos: Dict[str, LycoOnDisk] = {}
+loaded_lycos: List[LycoModule] = []
+
+list_available_lycos()

a1111-sd-webui-lycoris/preload.py

@@ -0,0 +1,6 @@
+import os
+from modules import paths
+
+
+def preload(parser):
+    parser.add_argument("--lyco-dir", type=str, help="Path to directory with LyCORIS networks.", default=os.path.join(paths.models_path, 'LyCORIS'))

a1111-sd-webui-lycoris/scripts/lycoris_script.py

@@ -0,0 +1,56 @@
+import torch
+import gradio as gr
+
+import lycoris
+import extra_networks_lyco
+import ui_extra_networks_lyco
+from modules import script_callbacks, ui_extra_networks, extra_networks, shared
+
+
+def unload():
+    torch.nn.Linear.forward = torch.nn.Linear_forward_before_lyco
+    torch.nn.Linear._load_from_state_dict = torch.nn.Linear_load_state_dict_before_lyco
+    torch.nn.Conv2d.forward = torch.nn.Conv2d_forward_before_lyco
+    torch.nn.Conv2d._load_from_state_dict = torch.nn.Conv2d_load_state_dict_before_lyco
+    torch.nn.MultiheadAttention.forward = torch.nn.MultiheadAttention_forward_before_lyco
+    torch.nn.MultiheadAttention._load_from_state_dict = torch.nn.MultiheadAttention_load_state_dict_before_lyco
+
+
+def before_ui():
+    ui_extra_networks.register_page(ui_extra_networks_lyco.ExtraNetworksPageLyCORIS())
+    extra_networks.register_extra_network(extra_networks_lyco.ExtraNetworkLyCORIS())
+
+
+if not hasattr(torch.nn, 'Linear_forward_before_lyco'):
+    torch.nn.Linear_forward_before_lyco = torch.nn.Linear.forward
+
+if not hasattr(torch.nn, 'Linear_load_state_dict_before_lyco'):
+    torch.nn.Linear_load_state_dict_before_lyco = torch.nn.Linear._load_from_state_dict
+
+if not hasattr(torch.nn, 'Conv2d_forward_before_lyco'):
+    torch.nn.Conv2d_forward_before_lyco = torch.nn.Conv2d.forward
+
+if not hasattr(torch.nn, 'Conv2d_load_state_dict_before_lyco'):
+    torch.nn.Conv2d_load_state_dict_before_lyco = torch.nn.Conv2d._load_from_state_dict
+
+if not hasattr(torch.nn, 'MultiheadAttention_forward_before_lyco'):
+    torch.nn.MultiheadAttention_forward_before_lyco = torch.nn.MultiheadAttention.forward
+
+if not hasattr(torch.nn, 'MultiheadAttention_load_state_dict_before_lyco'):
+    torch.nn.MultiheadAttention_load_state_dict_before_lyco = torch.nn.MultiheadAttention._load_from_state_dict
+
+torch.nn.Linear.forward = lycoris.lyco_Linear_forward
+torch.nn.Linear._load_from_state_dict = lycoris.lyco_Linear_load_state_dict
+torch.nn.Conv2d.forward = lycoris.lyco_Conv2d_forward
+torch.nn.Conv2d._load_from_state_dict = lycoris.lyco_Conv2d_load_state_dict
+torch.nn.MultiheadAttention.forward = lycoris.lyco_MultiheadAttention_forward
+torch.nn.MultiheadAttention._load_from_state_dict = lycoris.lyco_MultiheadAttention_load_state_dict
+
+script_callbacks.on_model_loaded(lycoris.assign_lyco_names_to_compvis_modules)
+script_callbacks.on_script_unloaded(unload)
+script_callbacks.on_before_ui(before_ui)
+
+
+shared.options_templates.update(shared.options_section(('extra_networks', "Extra Networks"), {
+    "sd_lyco": shared.OptionInfo("None", "Add LyCORIS to prompt", gr.Dropdown, lambda: {"choices": ["None"] + [x for x in lycoris.available_lycos]}, refresh=lycoris.list_available_lycos),
+}))

a1111-sd-webui-lycoris/ui_extra_networks_lyco.py

@@ -0,0 +1,35 @@
+import json
+import os
+import lycoris
+
+from modules import shared, ui_extra_networks
+
+
+class ExtraNetworksPageLyCORIS(ui_extra_networks.ExtraNetworksPage):
+    def __init__(self):
+        super().__init__('LyCORIS')
+
+    def refresh(self):
+        lycoris.list_available_lycos()
+
+    def list_items(self):
+        for name, lyco_on_disk in lycoris.available_lycos.items():
+            path, ext = os.path.splitext(lyco_on_disk.filename)
+            yield {
+                "name": name,
+                "filename": path,
+                "preview": self.find_preview(path),
+                "description": self.find_description(path),
+                "search_term": self.search_terms_from_path(lyco_on_disk.filename),
+                "prompt": (
+                    json.dumps(f"<lyco:{name}")
+                    + " + " + json.dumps(f':{shared.opts.extra_networks_default_multiplier}')
+                    + " + " + json.dumps(">")
+                ),
+                "local_preview": f"{path}.{shared.opts.samples_format}",
+                "metadata": json.dumps(lyco_on_disk.metadata, indent=4) if lyco_on_disk.metadata else None,
+            }
+
+    def allowed_directories_for_previews(self):
+        return [shared.cmd_opts.lyco_dir]
+

addtional/.github/workflows/typos.yml

@@ -0,0 +1,21 @@
+---
+# yamllint disable rule:line-length
+name: Typos
+
+on:  # yamllint disable-line rule:truthy
+  push:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: typos-action
+        uses: crate-ci/typos@v1.13.10

addtional/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+models/
+/hashes.json

addtional/LICENSE.txt

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

addtional/README.md

@@ -0,0 +1,210 @@
+## Additional Networks for generating images
+
+日本語の文章は下のほうにあります。
+
+[__Change History__](#change-history) is moved to the bottom of the page.
+更新履歴は[ページ末尾](#change-history)に移しました。
+
+Stable Diffusion web UI now seems to support LoRA trained by ``sd-scripts`` Thank you for great work!!!
+
+
+## About
+
+This extension is for [AUTOMATIC1111's Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui), allows the Web UI to add some networks (e.g. LoRA) to the original Stable Diffusion model to generate images. Currently LoRA is supported. The addition is on-the-fly, the merging is not required.
+
+This extension supports the LoRA models (*.ckpt or *.safetensors) trained by our scripts in [sd-scripts](https://github.com/kohya-ss/sd-scripts). The models from other LoRA implementations are not supported.
+
+This extension does not support training.
+
+Other networks other than LoRA may be supported in the future.
+
+## Installation
+
+1. Open "Extensions" tab.
+1. Open "Install from URL" tab in the tab.
+1. Enter URL of this repo to "URL for extension's git repository".
+1. Press "Install" button.
+1. Restart Web UI.
+
+## How to use
+
+Put the LoRA models (`*.pt`, `*.ckpt` or `*.safetensors`) inside the `sd-webui-additional-networks/models/LoRA` folder.
+
+Open __"Additional Networks"__ panel from the left bottom of Web UI.
+
+Press __"Refresh models"__ to update the models list.
+
+Select __"LoRA"__ for __"Network module 1"__.
+
+Choose __the name of the LoRA model file__ in __"Model 1"__.
+
+Set __the weight__ of the model (negative weight might be working but unexpected.)
+
+Repeat them for the module/model/weight 2 to 5 if you have other models. Models are applied in the order of 1 to 5.
+
+You can generate images with the model with these additional networks.
+
+## X/Y plot
+
+If you use LoRA models to plot, put the comma separated list of the model names into ``AddNet Model X`` 
+
+![image](https://user-images.githubusercontent.com/52813779/212444037-8ccd9157-c341-4eb4-82b4-64e3c8ee0237.png)
+
+You can get the list of models with the button next to ``Values``. Please select any model in ``Model ?`` at ``Additional Networks`` in order to make the button work. Models in the same folder as the model will be listed.
+
+![image](https://user-images.githubusercontent.com/52813779/212443639-97779d8d-0f7e-47f0-919c-41f053fe28a9.png)
+
+The metadata of the model can be drawn as legends. Move to ``Settings`` tab, select ``Additional Networks`` at left bottom, and set ``Metadata to show``. Available values are in ``Network metadata`` textbox in ``Additional Networks`` tab.
+
+![image](https://user-images.githubusercontent.com/52813779/212443781-1f4c442e-c2f3-47f8-b698-25fbe981f633.png)
+
+## Specify target region of LoRA by mask (__experimental__)
+
+Open `Extra args` and drop a mask image to `mask image`.
+
+By specifying with the mask image, each LoRA model can be applied only to the specified region of the image. Currently, only three models (Models 1 to 3) can be masked.
+
+The mask image is RGB image, with each channel (R, G and B) corresponding to LoRA models 1 to 3. Each channel can be overlapped. For example, yellow area (R and G) is applied to LoRA model 1 and 2. The range of values is 0 to 255, corresponding to a LoRA weight of 0 to 1.
+
+It can be combined with ControlNet.
+
+| |without ControlNet|with ControlNet|
+|:----:|:----:|:----:|
+|no LoRA|<img src="https://user-images.githubusercontent.com/52813779/223676928-362a68f0-b4c4-4905-9a5f-6646a39341f7.png" width="256">|<img src="https://user-images.githubusercontent.com/52813779/223677042-a7989dc8-741f-4d45-8328-be1f0bf08194.png" width="256">|
+|with LoRA, no mask|<img src="https://user-images.githubusercontent.com/52813779/223677327-b4237ff9-1d36-4cd9-971b-a3434db6d0f9.png" width="256">|<img src="https://user-images.githubusercontent.com/52813779/223677380-ba74bca0-92c3-4c68-950f-0f96e439281e.png" width="256">|
+|with Lora, with mask|<img src="https://user-images.githubusercontent.com/52813779/223677475-dff082c1-2a41-4d46-982d-db9655eb8bc2.png" width="256">|<img src="https://user-images.githubusercontent.com/52813779/223677518-0ae042ed-3baf-47f0-b8ca-3dd6805f7c2f.png" width="256">|
+| |pose|mask|
+| |<img src="https://user-images.githubusercontent.com/52813779/223677653-cfd7fb36-afc1-49e8-9253-4bc01c5dad99.png" width="256">|<img src="https://user-images.githubusercontent.com/52813779/223677672-5e2fc729-01ee-4c62-8457-2e125bb0e24f.png" width="256">
+
+Sample images are generated with [wd-1-5-beta2-aesthetic-fp16.safetensors](https://huggingface.co/waifu-diffusion/wd-1-5-beta2) and three LoRAs: two character LoRAs (model 1 and 2, masked, weight=1.0) and one style LoRA (model 4, not masked, weight=0.8). Used ControlNet is [diff_control_wd15beta2_pose.safetensors](https://huggingface.co/furusu/ControlNet).
+
+### Difference from 'Latent Couple extension' and 'Composable LoRA'
+
+'Latent Couple extension' masks the output of U-Net for each sub-prompt (AND-separated prompts), while our implementation masks the output of LoRA at each layer of U-Net. The mask is resized according to the tensor shape of each layer, so the resolution is particularly coarse at the deeper layers.
+
+'Composable LoRA' controls the area via 'Latent Couple extension' by switching LoRA on or off for each sub-prompt, but this implementation works alone.
+
+This implementation does not work for all modules in LoRA (the modules associated with Text Encoder are not masked), and due to the coarse resolution, it is not possible to completely separate areas.
+
+## この Web UI 拡張について
+
+LoRA などのネットワークを元の Stable Diffusion に追加し、画像生成を行うための拡張です。現在は LoRA のみ対応しています。
+
+この拡張で使えるのは[sd-scripts](https://github.com/kohya-ss/sd-scripts)リポジトリで学習した LoRA のモデル（\*.ckpt または \*.safetensors）です。他の LoRA リポジトリで学習したモデルは対応していません。
+
+この拡張単体では学習はできません。
+
+将来的に LoRA 以外のネットワークについてもサポートするかもしれません。
+
+## インストール
+
+1. Web UI で "Extensions" タブを開きます。
+1. さらに "Install from URL" タブを開きます。
+1. "URL for extension's git repository" 欄にこのリポジトリの URL を入れます。
+1. "Install"ボタンを押してインストールします。
+1. Web UI を再起動してください。
+
+## 使用法
+
+学習した LoRA のモデル(`*.pt`, `*.ckpt`, `*.safetensors`)を`sd-webui-additional-networks/models/LoRA`に置きます。
+
+Web UI の左下のほうの __"Additional Networks"__ のパネルを開きます。
+
+__"Network module 1"__ で __"LoRA"__ を選択してください。
+
+__"Refresh models"__ で LoRA モデルのリストを更新します。
+
+__"Model 1"__ に学習した LoRA のモデル名を選択します。
+
+__"Weight"__ にこのモデルの __重み__ を指定します（負の値も指定できますがどんな効果があるかは未知数です）。
+
+追加のモデルがある場合は 2～5 に指定してください。モデルは 1~5 の順番で適用されます。
+
+以上を指定すると、それぞれのモデルが適用された状態で画像生成されます。
+
+## X/Y plot
+
+LoRAモデルをX/Y plotの値（選択対象）として使う場合は、カンマ区切りのモデルのリストを与える必要があります。
+
+![image](https://user-images.githubusercontent.com/52813779/212444037-8ccd9157-c341-4eb4-82b4-64e3c8ee0237.png)
+
+モデルのリストは選択肢の隣にあるボタンで取得できます。いずれかのモデルを ``Additional Networks`` の ``Model ?`` で選択しておいてください。そのモデルと同じフォルダにあるモデルの一覧が取得されます。
+
+![image](https://user-images.githubusercontent.com/52813779/212443639-97779d8d-0f7e-47f0-919c-41f053fe28a9.png)
+
+モデルのメタデータ（学習時のパラメータなど）をX/Y plotのラベルに使用できます。Web UI上部の ``Settings`` タブを開き、左下から ``Additional Networks`` を選び、 ``Metadata to show`` にカンマ区切りで項目名を指定してください（``ss_learning_rate, ss_num_epochs`` のような感じになります）。使える値は ``Additional Networks`` の ``Network metadata`` 欄にある値です。
+
+![image](https://user-images.githubusercontent.com/52813779/212443781-1f4c442e-c2f3-47f8-b698-25fbe981f633.png)
+
+## LoRA の領域別適用 __（実験的機能）__
+
+適用する領域をマスク画像で指定することで、それぞれの LoRA モデルを画像の指定した部分にのみ適用することができます。現在はモデル1~3の3つのみ領域指定可能です。
+
+マスク画像はカラーの画像で、RGBの各チャネルが LoRA モデル1から3に対応します。RGBの各チャネルは重ねることが可能です。たとえば黄色（RとGチャネル）の領域は、モデル1と2が有効になります。ピクセル値0から255がLoRAの適用率0から1に対応します（127なら重み0.5で適用するのと同じになります）。
+
+マスク画像は生成画像サイズにリサイズされて適用されます。
+
+ControlNetと組み合わせることも可能です（細かい位置指定にはControlNetとの組み合わせを推奨します）。
+
+上のサンプルをご参照ください。
+
+### Latent Couple extension、Composable LoRAとの違い
+
+Latent Couple extension はサブプロンプト（ANDで区切られたプロンプト）ごとに、U-Net の出力をマスクしますが、当実装では U-Net の各層で LoRA の出力をマスクします。マスクは各層のテンソル形状に応じてリサイズされるため、深い層では特に解像度が粗くなります。
+
+Composable LoRA はサブプロンプトごとに LoRA の適用有無を��り替えることで Latent Couple extension を経由して影響範囲を制御しますが、当実装では単独で動作します。
+
+当実装はすべての LoRA モジュールに作用するわけではなく（Text Encoder に関連する LoRA モジュールはマスクされません）、また解像度が粗いため、完全に領域を分離することはできません。
+
+## Change History
+
+- 23 May 2023, 2023/5/23
+  - Fix an issue where the value of the `Weight` slider is not applied correctly.
+  - `Weight`のスライダーの値が正しく反映されない場合がある不具合への対応を行いました。
+  
+- 8 May 2023, 2023/5/8
+  - Fix an issue where the models are not loaded correctly in the `Additional Networks` tab.
+  - Fix an issue where `None` cannot be selected as a model in X/Y/Z plot.
+  - `Additional Networks`タブでモデルが正しく読み込まれない不具合を修正しました。
+  - X/Y/Z plotでモデルに `None` が選択できない不具合を修正しました。
+
+- 3 May 2023, 2023/5/3
+  - Fix an issue where an error occurs when selecting a model in X/Y/Z plot.
+  - X/Y/Z plotでモデル選択時にエラーとなる不具合を修正しました。
+- 6 Apr. 2023, 2023/4/6
+  - Fix an issue where the `Hires. fix` does not work with mask.
+  - 領域別LoRAでHires. fixが動作しない不具合を修正しました。
+- 30 Mar. 2023, 2023/3/30
+  - Fix an issue where the `Save Metadata` button in the metadata editor does not work even if `Editing Enabled` is checked.
+  - メタデータエディタで `Save Metadata` ボタンが `Editing Enabled` をチェックしても有効にならない不具合を修正しました。
+- 28 Mar. 2023, 2023/3/28
+  - Fix style for Gradio 3.22. Thanks to space-nuko!
+  - Please update Web UI to the latest version.
+  - Gradio 3.22 のスタイルに対応しました。space-nuko氏に感謝します。
+  - Web UIを最新版に更新願います。
+- 11 Mar. 2023, 2023/3/11
+  - Leading spaces in each path in `Extra paths to scan for LoRA models` settings are ignored. Thanks to tsukimiya!
+  - 設定の `Extra paths to scan for LoRA models` の各ディレクトリ名の先頭スペースを無視するよう変更しました。tsukimiya氏に感謝します。
+- 9 Mar. 2023, 2023/3/9: Release v0.5.1
+  - Fix the model saved with `bf16` causes an error. https://github.com/kohya-ss/sd-webui-additional-networks/issues/127
+  - Fix some Conv2d-3x3 LoRA modules are not effective. https://github.com/kohya-ss/sd-scripts/issues/275
+  - Fix LoRA modules with higher dim (rank) > 320 causes an error.
+  - `bf16` で学習されたモデルが読み込めない不具合を修正しました。 https://github.com/kohya-ss/sd-webui-additional-networks/issues/127
+  - いくつかの Conv2d-3x3 LoRA モジュールが有効にならない不具合を修正しました。 https://github.com/kohya-ss/sd-scripts/issues/275
+  - dim (rank) が 320 を超えるLoRAモデルが読み込めない不具合を修正しました。
+- 8 Mar. 2023, 2023/3/8: Release v0.5.0
+  - Support current version of [LoCon](https://github.com/KohakuBlueleaf/LoCon). __Thank you very much KohakuBlueleaf for your help!__
+    - LoCon will be enhanced in the future. Compatibility for future versions is not guaranteed.
+  - Support dynamic LoRA: different dimensions (ranks) and alpha for each module.
+  - Support LoRA for Conv2d (extended to conv2d with a kernel size not 1x1).
+  - Add masked LoRA feature (experimental.)
+  - 現在のバージョンの [LoCon](https://github.com/KohakuBlueleaf/LoCon) をサポートしました。 KohakuBlueleaf 氏のご支援に深く感謝します。
+    - LoCon が将来的に拡張された場合、それらのバージョンでの互換性は保証できません。
+  - dynamic LoRA の機能を追加しました。各モジュールで異なる dimension (rank) や alpha を持つ LoRA が使えます。
+  - Conv2d 拡張 LoRA をサポートしました。カーネルサイズが1x1でない Conv2d を対象とした LoRA が使えます。
+  - LoRA の適用領域指定機能を追加しました（実験的機能）。
+
+
+Please read [Releases](https://github.com/kohya-ss/sd-webui-additional-networks/releases) for recent updates.
+最近の更新情報は [Release](https://github.com/kohya-ss/sd-webui-additional-networks/releases) をご覧ください。
+