rework lora and patching system

and dora etc - backend rework is 60% finished
And I also removed the webui’s extremely annoying lora filter from model versions.

extensions-builtin/sd_forge_lora/extra_networks_lora.py

@@ -0,0 +1,62 @@
+from modules import extra_networks, shared
+import networks
+
+
+class ExtraNetworkLora(extra_networks.ExtraNetwork):
+    def __init__(self):
+        super().__init__('lora')
+
+        self.errors = {}
+        """mapping of network names to the number of errors the network had during operation"""
+
+    remove_symbols = str.maketrans('', '', ":,")
+
+    def activate(self, p, params_list):
+        additional = shared.opts.sd_lora
+
+        self.errors.clear()
+
+        if additional != "None" and additional in networks.available_networks and not any(x for x in params_list if x.items[0] == additional):
+            p.all_prompts = [x + f"<lora:{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 params.items
+
+            names.append(params.positional[0])
+
+            te_multiplier = float(params.positional[1]) if len(params.positional) > 1 else 1.0
+            te_multiplier = float(params.named.get("te", te_multiplier))
+
+            unet_multiplier = float(params.positional[2]) if len(params.positional) > 2 else te_multiplier
+            unet_multiplier = float(params.named.get("unet", unet_multiplier))
+
+            dyn_dim = int(params.positional[3]) if len(params.positional) > 3 else None
+            dyn_dim = int(params.named["dyn"]) if "dyn" in params.named else dyn_dim
+
+            te_multipliers.append(te_multiplier)
+            unet_multipliers.append(unet_multiplier)
+            dyn_dims.append(dyn_dim)
+
+        networks.load_networks(names, te_multipliers, unet_multipliers, dyn_dims)
+
+        if shared.opts.lora_add_hashes_to_infotext:
+            if not getattr(p, "is_hr_pass", False) or not hasattr(p, "lora_hashes"):
+                p.lora_hashes = {}
+
+            for item in networks.loaded_networks:
+                if item.network_on_disk.shorthash and item.mentioned_name:
+                    p.lora_hashes[item.mentioned_name.translate(self.remove_symbols)] = item.network_on_disk.shorthash
+
+            if p.lora_hashes:
+                p.extra_generation_params["Lora hashes"] = ', '.join(f'{k}: {v}' for k, v in p.lora_hashes.items())
+
+    def deactivate(self, p):
+        if self.errors:
+            p.comment("Networks with errors: " + ", ".join(f"{k} ({v})" for k, v in self.errors.items()))
+
+            self.errors.clear()

extensions-builtin/sd_forge_lora/lora.py

@@ -0,0 +1,9 @@
+import networks
+
+list_available_loras = networks.list_available_networks
+
+available_loras = networks.available_networks
+available_lora_aliases = networks.available_network_aliases
+available_lora_hash_lookup = networks.available_network_hash_lookup
+forbidden_lora_aliases = networks.forbidden_network_aliases
+loaded_loras = networks.loaded_networks

extensions-builtin/sd_forge_lora/lora_logger.py

@@ -0,0 +1,33 @@
+import sys
+import copy
+import logging
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[0;36m",  # CYAN
+        "INFO": "\033[0;32m",  # GREEN
+        "WARNING": "\033[0;33m",  # YELLOW
+        "ERROR": "\033[0;31m",  # RED
+        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
+        "RESET": "\033[0m",  # RESET COLOR
+    }
+
+    def format(self, record):
+        colored_record = copy.copy(record)
+        levelname = colored_record.levelname
+        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
+        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
+        return super().format(colored_record)
+
+
+logger = logging.getLogger("lora")
+logger.propagate = False
+
+
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(
+        ColoredFormatter("[%(name)s]-%(levelname)s: %(message)s")
+    )
+    logger.addHandler(handler)

extensions-builtin/sd_forge_lora/network.py

@@ -0,0 +1,74 @@
+import os
+
+from modules import sd_models, cache, errors, hashes, shared
+
+
+metadata_tags_order = {"ss_sd_model_name": 1, "ss_resolution": 2, "ss_clip_skip": 3, "ss_num_train_images": 10, "ss_tag_frequency": 20}
+
+
+class NetworkOnDisk:
+    def __init__(self, name, filename):
+        self.name = name
+        self.filename = filename
+        self.metadata = {}
+        self.is_safetensors = os.path.splitext(filename)[1].lower() == ".safetensors"
+
+        def read_metadata():
+            metadata = sd_models.read_metadata_from_safetensors(filename)
+
+            return metadata
+
+        if self.is_safetensors:
+            try:
+                self.metadata = cache.cached_data_for_file('safetensors-metadata', "lora/" + self.name, filename, read_metadata)
+            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.alias = self.metadata.get('ss_output_name', self.name)
+
+        self.hash = None
+        self.shorthash = None
+        self.set_hash(
+            self.metadata.get('sshs_model_hash') or
+            hashes.sha256_from_cache(self.filename, "lora/" + self.name, use_addnet_hash=self.is_safetensors) or
+            ''
+        )
+
+    def set_hash(self, v):
+        self.hash = v
+        self.shorthash = self.hash[0:12]
+
+        if self.shorthash:
+            import networks
+            networks.available_network_hash_lookup[self.shorthash] = self
+
+    def read_hash(self):
+        if not self.hash:
+            self.set_hash(hashes.sha256(self.filename, "lora/" + self.name, use_addnet_hash=self.is_safetensors) or '')
+
+    def get_alias(self):
+        import networks
+        if shared.opts.lora_preferred_name == "Filename" or self.alias.lower() in networks.forbidden_network_aliases:
+            return self.name
+        else:
+            return self.alias
+
+
+class Network:
+    def __init__(self, name, network_on_disk: NetworkOnDisk):
+        self.name = name
+        self.network_on_disk = network_on_disk
+        self.te_multiplier = 1.0
+        self.unet_multiplier = 1.0
+        self.dyn_dim = None
+        self.modules = {}
+        self.bundle_embeddings = {}
+        self.mtime = None
+        self.mentioned_name = None

extensions-builtin/sd_forge_lora/networks.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+import gradio as gr
+import logging
+import os
+import re
+
+import functools
+import network
+
+import torch
+from typing import Union
+
+from modules import shared, sd_models, errors, scripts
+from ldm_patched.modules.utils import load_torch_file
+from ldm_patched.modules.sd import load_lora_for_models
+
+
+@functools.lru_cache(maxsize=5)
+def load_lora_state_dict(filename):
+    return load_torch_file(filename, safe_load=True)
+
+
+def load_network(name, network_on_disk):
+    net = network.Network(name, network_on_disk)
+    net.mtime = os.path.getmtime(network_on_disk.filename)
+
+    return net
+
+
+def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
+    global lora_state_dict_cache
+
+    current_sd = sd_models.model_data.get_sd_model()
+    if current_sd is None:
+        return
+
+    loaded_networks.clear()
+
+    unavailable_networks = []
+    for name in names:
+        if name.lower() in forbidden_network_aliases and available_networks.get(name) is None:
+            unavailable_networks.append(name)
+        elif available_network_aliases.get(name) is None:
+            unavailable_networks.append(name)
+
+    if unavailable_networks:
+        update_available_networks_by_names(unavailable_networks)
+
+    networks_on_disk = [available_networks.get(name, None) if name.lower() in forbidden_network_aliases else available_network_aliases.get(name, None) for name in names]
+    if any(x is None for x in networks_on_disk):
+        list_available_networks()
+        networks_on_disk = [available_networks.get(name, None) if name.lower() in forbidden_network_aliases else available_network_aliases.get(name, None) for name in names]
+
+    for i, (network_on_disk, name) in enumerate(zip(networks_on_disk, names)):
+        try:
+            net = load_network(name, network_on_disk)
+        except Exception as e:
+            errors.display(e, f"loading network {network_on_disk.filename}")
+            continue
+        net.mentioned_name = name
+        network_on_disk.read_hash()
+        loaded_networks.append(net)
+
+    compiled_lora_targets = []
+    for a, b, c in zip(networks_on_disk, unet_multipliers, te_multipliers):
+        compiled_lora_targets.append([a.filename, b, c])
+
+    compiled_lora_targets_hash = str(compiled_lora_targets)
+
+    if current_sd.current_lora_hash == compiled_lora_targets_hash:
+        return
+
+    current_sd.current_lora_hash = compiled_lora_targets_hash
+    current_sd.forge_objects.unet = current_sd.forge_objects_original.unet
+    current_sd.forge_objects.clip = current_sd.forge_objects_original.clip
+
+    for filename, strength_model, strength_clip in compiled_lora_targets:
+        lora_sd = load_lora_state_dict(filename)
+        current_sd.forge_objects.unet, current_sd.forge_objects.clip = load_lora_for_models(
+            current_sd.forge_objects.unet, current_sd.forge_objects.clip, lora_sd, strength_model, strength_clip,
+            filename=filename)
+
+    current_sd.forge_objects_after_applying_lora = current_sd.forge_objects.shallow_copy()
+    return
+
+
+def process_network_files(names: list[str] | None = None):
+    candidates = list(shared.walk_files(shared.cmd_opts.lora_dir, allowed_extensions=[".pt", ".ckpt", ".safetensors"]))
+    for filename in candidates:
+        if os.path.isdir(filename):
+            continue
+        name = os.path.splitext(os.path.basename(filename))[0]
+        # if names is provided, only load networks with names in the list
+        if names and name not in names:
+            continue
+        try:
+            entry = network.NetworkOnDisk(name, filename)
+        except OSError:  # should catch FileNotFoundError and PermissionError etc.
+            errors.report(f"Failed to load network {name} from {filename}", exc_info=True)
+            continue
+
+        available_networks[name] = entry
+
+        if entry.alias in available_network_aliases:
+            forbidden_network_aliases[entry.alias.lower()] = 1
+
+        available_network_aliases[name] = entry
+        available_network_aliases[entry.alias] = entry
+
+
+def update_available_networks_by_names(names: list[str]):
+    process_network_files(names)
+
+
+def list_available_networks():
+    available_networks.clear()
+    available_network_aliases.clear()
+    forbidden_network_aliases.clear()
+    available_network_hash_lookup.clear()
+    forbidden_network_aliases.update({"none": 1, "Addams": 1})
+
+    os.makedirs(shared.cmd_opts.lora_dir, exist_ok=True)
+
+    process_network_files()
+
+
+re_network_name = re.compile(r"(.*)\s*\([0-9a-fA-F]+\)")
+
+
+def infotext_pasted(infotext, params):
+    if "AddNet Module 1" in [x[1] for x in scripts.scripts_txt2img.infotext_fields]:
+        return  # if the other extension is active, it will handle those fields, no need to do anything
+
+    added = []
+
+    for k in params:
+        if not k.startswith("AddNet Model "):
+            continue
+
+        num = k[13:]
+
+        if params.get("AddNet Module " + num) != "LoRA":
+            continue
+
+        name = params.get("AddNet Model " + num)
+        if name is None:
+            continue
+
+        m = re_network_name.match(name)
+        if m:
+            name = m.group(1)
+
+        multiplier = params.get("AddNet Weight A " + num, "1.0")
+
+        added.append(f"<lora:{name}:{multiplier}>")
+
+    if added:
+        params["Prompt"] += "\n" + "".join(added)
+
+
+extra_network_lora = None
+
+available_networks = {}
+available_network_aliases = {}
+loaded_networks = []
+loaded_bundle_embeddings = {}
+networks_in_memory = {}
+available_network_hash_lookup = {}
+forbidden_network_aliases = {}
+
+list_available_networks()

extensions-builtin/sd_forge_lora/preload.py

@@ -0,0 +1,8 @@
+import os
+from modules import paths
+from modules.paths_internal import normalized_filepath
+
+
+def preload(parser):
+    parser.add_argument("--lora-dir", type=normalized_filepath, help="Path to directory with Lora networks.", default=os.path.join(paths.models_path, 'Lora'))
+    parser.add_argument("--lyco-dir-backcompat", type=normalized_filepath, help="Path to directory with LyCORIS networks (for backawards compatibility; can also use --lyco-dir).", default=os.path.join(paths.models_path, 'LyCORIS'))

extensions-builtin/sd_forge_lora/scripts/lora_script.py

@@ -0,0 +1,90 @@
+import re
+
+import gradio as gr
+from fastapi import FastAPI
+
+import network
+import networks
+import lora  # noqa:F401
+import extra_networks_lora
+import ui_extra_networks_lora
+from modules import script_callbacks, ui_extra_networks, extra_networks, shared
+
+
+def before_ui():
+    ui_extra_networks.register_page(ui_extra_networks_lora.ExtraNetworksPageLora())
+
+    networks.extra_network_lora = extra_networks_lora.ExtraNetworkLora()
+    extra_networks.register_extra_network(networks.extra_network_lora)
+
+
+script_callbacks.on_before_ui(before_ui)
+script_callbacks.on_infotext_pasted(networks.infotext_pasted)
+
+
+shared.options_templates.update(shared.options_section(('extra_networks', "Extra Networks"), {
+    "sd_lora": shared.OptionInfo("None", "Add network to prompt", gr.Dropdown, lambda: {"choices": ["None", *networks.available_networks]}, refresh=networks.list_available_networks),
+    "lora_preferred_name": shared.OptionInfo("Alias from file", "When adding to prompt, refer to Lora by", gr.Radio, {"choices": ["Alias from file", "Filename"]}),
+    "lora_add_hashes_to_infotext": shared.OptionInfo(True, "Add Lora hashes to infotext"),
+    "lora_bundled_ti_to_infotext": shared.OptionInfo(True, "Add Lora name as TI hashes for bundled Textual Inversion").info('"Add Textual Inversion hashes to infotext" needs to be enabled'),
+    "lora_filter_disabled": shared.OptionInfo(True, "Always show all networks on the Lora page").info("otherwise, those detected as for incompatible version of Stable Diffusion will be hidden"),
+    "lora_hide_unknown_for_versions": shared.OptionInfo([], "Hide networks of unknown versions for model versions", gr.CheckboxGroup, {"choices": ["SD1", "SD2", "SDXL"]}),
+    "lora_in_memory_limit": shared.OptionInfo(0, "Number of Lora networks to keep cached in memory", gr.Number, {"precision": 0}),
+    "lora_not_found_warning_console": shared.OptionInfo(False, "Lora not found warning in console"),
+    "lora_not_found_gradio_warning": shared.OptionInfo(False, "Lora not found warning popup in webui"),
+}))
+
+
+shared.options_templates.update(shared.options_section(('compatibility', "Compatibility"), {
+    "lora_functional": shared.OptionInfo(False, "Lora/Networks: use old method that takes longer when you have multiple Loras active and produces same results as kohya-ss/sd-webui-additional-networks extension"),
+}))
+
+
+def create_lora_json(obj: network.NetworkOnDisk):
+    return {
+        "name": obj.name,
+        "alias": obj.alias,
+        "path": obj.filename,
+        "metadata": obj.metadata,
+    }
+
+
+def api_networks(_: gr.Blocks, app: FastAPI):
+    @app.get("/sdapi/v1/loras")
+    async def get_loras():
+        return [create_lora_json(obj) for obj in networks.available_networks.values()]
+
+    @app.post("/sdapi/v1/refresh-loras")
+    async def refresh_loras():
+        return networks.list_available_networks()
+
+
+script_callbacks.on_app_started(api_networks)
+
+re_lora = re.compile("<lora:([^:]+):")
+
+
+def infotext_pasted(infotext, d):
+    hashes = d.get("Lora hashes")
+    if not hashes:
+        return
+
+    hashes = [x.strip().split(':', 1) for x in hashes.split(",")]
+    hashes = {x[0].strip().replace(",", ""): x[1].strip() for x in hashes}
+
+    def network_replacement(m):
+        alias = m.group(1)
+        shorthash = hashes.get(alias)
+        if shorthash is None:
+            return m.group(0)
+
+        network_on_disk = networks.available_network_hash_lookup.get(shorthash)
+        if network_on_disk is None:
+            return m.group(0)
+
+        return f'<lora:{network_on_disk.get_alias()}:'
+
+    d["Prompt"] = re.sub(re_lora, network_replacement, d["Prompt"])
+
+
+script_callbacks.on_infotext_pasted(infotext_pasted)

extensions-builtin/sd_forge_lora/ui_edit_user_metadata.py

@@ -0,0 +1,226 @@
+import datetime
+import html
+import random
+
+import gradio as gr
+import re
+
+from modules import ui_extra_networks_user_metadata
+
+
+def is_non_comma_tagset(tags):
+    average_tag_length = sum(len(x) for x in tags.keys()) / len(tags)
+
+    return average_tag_length >= 16
+
+
+re_word = re.compile(r"[-_\w']+")
+re_comma = re.compile(r" *, *")
+
+
+def build_tags(metadata):
+    tags = {}
+
+    ss_tag_frequency = metadata.get("ss_tag_frequency", {})
+    if ss_tag_frequency is not None and hasattr(ss_tag_frequency, 'items'):
+        for _, tags_dict in ss_tag_frequency.items():
+            for tag, tag_count in tags_dict.items():
+                tag = tag.strip()
+                tags[tag] = tags.get(tag, 0) + int(tag_count)
+
+    if tags and is_non_comma_tagset(tags):
+        new_tags = {}
+
+        for text, text_count in tags.items():
+            for word in re.findall(re_word, text):
+                if len(word) < 3:
+                    continue
+
+                new_tags[word] = new_tags.get(word, 0) + text_count
+
+        tags = new_tags
+
+    ordered_tags = sorted(tags.keys(), key=tags.get, reverse=True)
+
+    return [(tag, tags[tag]) for tag in ordered_tags]
+
+
+class LoraUserMetadataEditor(ui_extra_networks_user_metadata.UserMetadataEditor):
+    def __init__(self, ui, tabname, page):
+        super().__init__(ui, tabname, page)
+
+        self.select_sd_version = None
+
+        self.taginfo = None
+        self.edit_activation_text = None
+        self.slider_preferred_weight = None
+        self.edit_notes = None
+
+    def save_lora_user_metadata(self, name, desc, sd_version, activation_text, preferred_weight, negative_text, notes):
+        user_metadata = self.get_user_metadata(name)
+        user_metadata["description"] = desc
+        user_metadata["sd version"] = sd_version
+        user_metadata["activation text"] = activation_text
+        user_metadata["preferred weight"] = preferred_weight
+        user_metadata["negative text"] = negative_text
+        user_metadata["notes"] = notes
+
+        self.write_user_metadata(name, user_metadata)
+
+    def get_metadata_table(self, name):
+        table = super().get_metadata_table(name)
+        item = self.page.items.get(name, {})
+        metadata = item.get("metadata") or {}
+
+        keys = {
+            'ss_output_name': "Output name:",
+            'ss_sd_model_name': "Model:",
+            'ss_clip_skip': "Clip skip:",
+            'ss_network_module': "Kohya module:",
+        }
+
+        for key, label in keys.items():
+            value = metadata.get(key, None)
+            if value is not None and str(value) != "None":
+                table.append((label, html.escape(value)))
+
+        ss_training_started_at = metadata.get('ss_training_started_at')
+        if ss_training_started_at:
+            table.append(("Date trained:", datetime.datetime.utcfromtimestamp(float(ss_training_started_at)).strftime('%Y-%m-%d %H:%M')))
+
+        ss_bucket_info = metadata.get("ss_bucket_info")
+        if ss_bucket_info and "buckets" in ss_bucket_info:
+            resolutions = {}
+            for _, bucket in ss_bucket_info["buckets"].items():
+                resolution = bucket["resolution"]
+                resolution = f'{resolution[1]}x{resolution[0]}'
+
+                resolutions[resolution] = resolutions.get(resolution, 0) + int(bucket["count"])
+
+            resolutions_list = sorted(resolutions.keys(), key=resolutions.get, reverse=True)
+            resolutions_text = html.escape(", ".join(resolutions_list[0:4]))
+            if len(resolutions) > 4:
+                resolutions_text += ", ..."
+                resolutions_text = f"<span title='{html.escape(', '.join(resolutions_list))}'>{resolutions_text}</span>"
+
+            table.append(('Resolutions:' if len(resolutions_list) > 1 else 'Resolution:', resolutions_text))
+
+        image_count = 0
+        for _, params in metadata.get("ss_dataset_dirs", {}).items():
+            image_count += int(params.get("img_count", 0))
+
+        if image_count:
+            table.append(("Dataset size:", image_count))
+
+        return table
+
+    def put_values_into_components(self, name):
+        user_metadata = self.get_user_metadata(name)
+        values = super().put_values_into_components(name)
+
+        item = self.page.items.get(name, {})
+        metadata = item.get("metadata") or {}
+
+        tags = build_tags(metadata)
+        gradio_tags = [(tag, str(count)) for tag, count in tags[0:24]]
+
+        return [
+            *values[0:5],
+            item.get("sd_version", "Unknown"),
+            gr.HighlightedText.update(value=gradio_tags, visible=True if tags else False),
+            user_metadata.get('activation text', ''),
+            float(user_metadata.get('preferred weight', 0.0)),
+            user_metadata.get('negative text', ''),
+            gr.update(visible=True if tags else False),
+            gr.update(value=self.generate_random_prompt_from_tags(tags), visible=True if tags else False),
+        ]
+
+    def generate_random_prompt(self, name):
+        item = self.page.items.get(name, {})
+        metadata = item.get("metadata") or {}
+        tags = build_tags(metadata)
+
+        return self.generate_random_prompt_from_tags(tags)
+
+    def generate_random_prompt_from_tags(self, tags):
+        max_count = None
+        res = []
+        for tag, count in tags:
+            if not max_count:
+                max_count = count
+
+            v = random.random() * max_count
+            if count > v:
+                for x in "({[]})":
+                    tag = tag.replace(x, '\\' + x)
+                res.append(tag)
+
+        return ", ".join(sorted(res))
+
+    def create_extra_default_items_in_left_column(self):
+
+        # this would be a lot better as gr.Radio but I can't make it work
+        self.select_sd_version = gr.Dropdown(['SD1', 'SD2', 'SDXL', 'Unknown'], value='Unknown', label='Stable Diffusion version', interactive=True)
+
+    def create_editor(self):
+        self.create_default_editor_elems()
+
+        self.taginfo = gr.HighlightedText(label="Training dataset tags")
+        self.edit_activation_text = gr.Text(label='Activation text', info="Will be added to prompt along with Lora")
+        self.slider_preferred_weight = gr.Slider(label='Preferred weight', info="Set to 0 to disable", minimum=0.0, maximum=2.0, step=0.01)
+        self.edit_negative_text = gr.Text(label='Negative prompt', info="Will be added to negative prompts")
+        with gr.Row() as row_random_prompt:
+            with gr.Column(scale=8):
+                random_prompt = gr.Textbox(label='Random prompt', lines=4, max_lines=4, interactive=False)
+
+            with gr.Column(scale=1, min_width=120):
+                generate_random_prompt = gr.Button('Generate', size="lg", scale=1)
+
+        self.edit_notes = gr.TextArea(label='Notes', lines=4)
+
+        generate_random_prompt.click(fn=self.generate_random_prompt, inputs=[self.edit_name_input], outputs=[random_prompt], show_progress=False)
+
+        def select_tag(activation_text, evt: gr.SelectData):
+            tag = evt.value[0]
+
+            words = re.split(re_comma, activation_text)
+            if tag in words:
+                words = [x for x in words if x != tag and x.strip()]
+                return ", ".join(words)
+
+            return activation_text + ", " + tag if activation_text else tag
+
+        self.taginfo.select(fn=select_tag, inputs=[self.edit_activation_text], outputs=[self.edit_activation_text], show_progress=False)
+
+        self.create_default_buttons()
+
+        viewed_components = [
+            self.edit_name,
+            self.edit_description,
+            self.html_filedata,
+            self.html_preview,
+            self.edit_notes,
+            self.select_sd_version,
+            self.taginfo,
+            self.edit_activation_text,
+            self.slider_preferred_weight,
+            self.edit_negative_text,
+            row_random_prompt,
+            random_prompt,
+        ]
+
+        self.button_edit\
+            .click(fn=self.put_values_into_components, inputs=[self.edit_name_input], outputs=viewed_components)\
+            .then(fn=lambda: gr.update(visible=True), inputs=[], outputs=[self.box])
+
+        edited_components = [
+            self.edit_description,
+            self.select_sd_version,
+            self.edit_activation_text,
+            self.slider_preferred_weight,
+            self.edit_negative_text,
+            self.edit_notes,
+        ]
+
+
+        self.setup_save_handler(self.button_save, self.save_lora_user_metadata, edited_components)

extensions-builtin/sd_forge_lora/ui_extra_networks_lora.py

@@ -0,0 +1,69 @@
+import os
+
+import network
+import networks
+
+from modules import shared, ui_extra_networks
+from modules.ui_extra_networks import quote_js
+from ui_edit_user_metadata import LoraUserMetadataEditor
+
+
+class ExtraNetworksPageLora(ui_extra_networks.ExtraNetworksPage):
+    def __init__(self):
+        super().__init__('Lora')
+
+    def refresh(self):
+        networks.list_available_networks()
+
+    def create_item(self, name, index=None, enable_filter=True):
+        lora_on_disk = networks.available_networks.get(name)
+        if lora_on_disk is None:
+            return
+
+        path, ext = os.path.splitext(lora_on_disk.filename)
+
+        alias = lora_on_disk.get_alias()
+
+        search_terms = [self.search_terms_from_path(lora_on_disk.filename)]
+        if lora_on_disk.hash:
+            search_terms.append(lora_on_disk.hash)
+        item = {
+            "name": name,
+            "filename": lora_on_disk.filename,
+            "shorthash": lora_on_disk.shorthash,
+            "preview": self.find_preview(path) or self.find_embedded_preview(path, name, lora_on_disk.metadata),
+            "description": self.find_description(path),
+            "search_terms": search_terms,
+            "local_preview": f"{path}.{shared.opts.samples_format}",
+            "metadata": lora_on_disk.metadata,
+            "sort_keys": {'default': index, **self.get_sort_keys(lora_on_disk.filename)},
+        }
+
+        self.read_user_metadata(item)
+        activation_text = item["user_metadata"].get("activation text")
+        preferred_weight = item["user_metadata"].get("preferred weight", 0.0)
+        item["prompt"] = quote_js(f"<lora:{alias}:") + " + " + (str(preferred_weight) if preferred_weight else "opts.extra_networks_default_multiplier") + " + " + quote_js(">")
+
+        if activation_text:
+            item["prompt"] += " + " + quote_js(" " + activation_text)
+
+        negative_prompt = item["user_metadata"].get("negative text")
+        item["negative_prompt"] = quote_js("")
+        if negative_prompt:
+            item["negative_prompt"] = quote_js('(' + negative_prompt + ':1)')
+
+        return item
+
+    def list_items(self):
+        # instantiate a list to protect against concurrent modification
+        names = list(networks.available_networks)
+        for index, name in enumerate(names):
+            item = self.create_item(name, index)
+            if item is not None:
+                yield item
+
+    def allowed_directories_for_previews(self):
+        return [shared.cmd_opts.lora_dir]
+
+    def create_user_metadata_editor(self, ui, tabname):
+        return LoraUserMetadataEditor(ui, tabname, self)