load thread locks

Signed-off-by: Vladimir Mandic <mandic00@live.com>
2026-09-20 01:31:13 +02:00 · 2025-01-10 13:21:09 -05:00
parent 85a6aca1cc
commit dc26d32aed
13 changed files with 228 additions and 188 deletions
@@ -26,6 +26,7 @@
  - refactored progress monitoring, job updates and live preview  
  - improved metadata save and restore  
  - startup tracing and optimizations  
+  - threading load locks on model loads
 - **Schedulers**:
  - [TDD](https://github.com/RedAIGC/Target-Driven-Distillation) new super-fast scheduler that can generate images in 4-8 steps  
    recommended to use with [TDD LoRA](https://huggingface.co/RED-AIGC/TDD/tree/main)  
@@ -55,7 +56,6 @@
  - flux support on-the-fly quantization for bnb of unet only  
  - control restore pipeline before running hires  
  - restore args after batch run  
-  - control add load lock  

 ## Update for 2024-12-31

@@ -1397,11 +1397,20 @@ def add_args(parser):
    group_log.add_argument('--docs', default=os.environ.get("SD_DOCS", False), action='store_true', help="Mount API docs, default: %(default)s")
    group_log.add_argument("--api-log", default=os.environ.get("SD_APILOG", True), action='store_true', help="Log all API requests")

+    group_nargs = parser.add_argument_group('Other')
+    group_nargs.add_argument('args', type=str, nargs='*')
+

 def parse_args(parser):
    # command line args
    global args # pylint: disable=global-statement
-    args = parser.parse_args()
+    if "USED_VSCODE_COMMAND_PICKARGS" in os.environ:
+        import shlex
+        argv = shlex.split(" ".join(sys.argv[1:])) if "USED_VSCODE_COMMAND_PICKARGS" in os.environ else sys.argv[1:]
+        log.debug('VSCode Launch')
+        args = parser.parse_args(argv)
+    else:
+        args = parser.parse_args()
    return args


@@ -1,4 +1,5 @@
 import os
+import sys
 import argparse
 from modules.paths import data_path

@@ -154,7 +155,12 @@ def settings_args(opts, args):
    opts.onchange("lora_dir", lambda: setattr(args, "lora_dir", opts.lora_dir))
    opts.onchange("lyco_dir", lambda: setattr(args, "lyco_dir", opts.lyco_dir))

-    args = parser.parse_args()
+    if "USED_VSCODE_COMMAND_PICKARGS" in os.environ:
+        import shlex
+        argv = shlex.split(" ".join(sys.argv[1:])) if "USED_VSCODE_COMMAND_PICKARGS" in os.environ else sys.argv[1:]
+        args = parser.parse_args(argv)
+    else:
+        args = parser.parse_args()
    return args


@@ -1,6 +1,7 @@
 import os
 import time
 from typing import Union
+import threading
 import numpy as np
 from PIL import Image
 from diffusers import StableDiffusionPipeline, StableDiffusionXLPipeline
@@ -27,6 +28,7 @@ all_models = {}
 all_models.update(predefined_sd15)
 all_models.update(predefined_sdxl)
 cache_dir = 'models/control/lite'
+load_lock = threading.Lock()


 def find_models():
@@ -79,44 +81,45 @@ class ControlLLLite():
        self.model_id = None

    def load(self, model_id: str = None, force: bool = True) -> str:
-        try:
-            t0 = time.time()
-            model_id = model_id or self.model_id
-            if model_id is None or model_id == 'None':
-                self.reset()
-                return
-            if model_id not in all_models:
-                log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
-                return
-            model_path = all_models[model_id]
-            if model_path == '':
-                return
-            if model_path is None:
-                log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
-                return
-            if model_id == self.model_id and not force:
-                # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
-                return
-            log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}" {self.load_config}')
-            if model_path.endswith('.safetensors'):
-                self.model = ControlNetLLLite(model_path)
-            else:
-                import huggingface_hub as hf
-                folder, filename = os.path.split(model_path)
-                model_path = hf.hf_hub_download(repo_id=folder, filename=f'{filename}.safetensors', cache_dir=cache_dir)
-                self.model = ControlNetLLLite(model_path)
-            if self.device is not None:
-                self.model.to(self.device)
-            if self.dtype is not None:
-                self.model.to(self.dtype)
-            t1 = time.time()
-            self.model_id = model_id
-            log.debug(f'Control {what} model loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
-            return f'{what} loaded model: {model_id}'
-        except Exception as e:
-            log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
-            errors.display(e, f'Control {what} load')
-            return f'{what} failed to load model: {model_id}'
+        with load_lock:
+            try:
+                t0 = time.time()
+                model_id = model_id or self.model_id
+                if model_id is None or model_id == 'None':
+                    self.reset()
+                    return
+                if model_id not in all_models:
+                    log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
+                    return
+                model_path = all_models[model_id]
+                if model_path == '':
+                    return
+                if model_path is None:
+                    log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
+                    return
+                if model_id == self.model_id and not force:
+                    # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
+                    return
+                log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}" {self.load_config}')
+                if model_path.endswith('.safetensors'):
+                    self.model = ControlNetLLLite(model_path)
+                else:
+                    import huggingface_hub as hf
+                    folder, filename = os.path.split(model_path)
+                    model_path = hf.hf_hub_download(repo_id=folder, filename=f'{filename}.safetensors', cache_dir=cache_dir)
+                    self.model = ControlNetLLLite(model_path)
+                if self.device is not None:
+                    self.model.to(self.device)
+                if self.dtype is not None:
+                    self.model.to(self.dtype)
+                t1 = time.time()
+                self.model_id = model_id
+                log.debug(f'Control {what} model loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
+                return f'{what} loaded model: {model_id}'
+            except Exception as e:
+                log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
+                errors.display(e, f'Control {what} load')
+                return f'{what} failed to load model: {model_id}'


 class ControlLLitePipeline():
@@ -1,6 +1,7 @@
 import os
 import time
 from typing import Union
+import threading
 from diffusers import StableDiffusionPipeline, StableDiffusionXLPipeline, T2IAdapter, MultiAdapter, StableDiffusionAdapterPipeline, StableDiffusionXLAdapterPipeline # pylint: disable=unused-import
 from modules.shared import log
 from modules import errors, sd_models
@@ -43,6 +44,7 @@ all_models = {}
 all_models.update(predefined_sd15)
 all_models.update(predefined_sdxl)
 cache_dir = 'models/control/adapter'
+load_lock = threading.Lock()


 def list_models(refresh=False):
@@ -87,45 +89,46 @@ class Adapter():
        self.model_id = None

    def load(self, model_id: str = None, force: bool = True) -> str:
-        try:
-            t0 = time.time()
-            model_id = model_id or self.model_id
-            if model_id is None or model_id == 'None':
-                self.reset()
-                return
-            if model_id not in all_models:
-                log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
-                return
-            model_path, model_args = all_models[model_id]
-            self.load_config.update(model_args)
-            if model_path is None:
-                log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
-                return
-            if model_id == self.model_id and not force:
-                # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
-                return
-            log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}"')
-            if model_path.endswith('.pth') or model_path.endswith('.pt') or model_path.endswith('.safetensors') or model_path.endswith('.bin'):
-                from huggingface_hub import hf_hub_download
-                parts = model_path.split('/')
-                repo_id = f'{parts[0]}/{parts[1]}'
-                filename = '/'.join(parts[2:])
-                model = hf_hub_download(repo_id, filename, **self.load_config)
-                self.model = T2IAdapter.from_pretrained(model, **self.load_config)
-            else:
-                self.model = T2IAdapter.from_pretrained(model_path, **self.load_config)
-            if self.device is not None:
-                self.model.to(self.device)
-            if self.dtype is not None:
-                self.model.to(self.dtype)
-            t1 = time.time()
-            self.model_id = model_id
-            log.debug(f'Control {what} loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
-            return f'{what} loaded model: {model_id}'
-        except Exception as e:
-            log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
-            errors.display(e, f'Control {what} load')
-            return f'{what} failed to load model: {model_id}'
+        with load_lock:
+            try:
+                t0 = time.time()
+                model_id = model_id or self.model_id
+                if model_id is None or model_id == 'None':
+                    self.reset()
+                    return
+                if model_id not in all_models:
+                    log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
+                    return
+                model_path, model_args = all_models[model_id]
+                self.load_config.update(model_args)
+                if model_path is None:
+                    log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
+                    return
+                if model_id == self.model_id and not force:
+                    # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
+                    return
+                log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}"')
+                if model_path.endswith('.pth') or model_path.endswith('.pt') or model_path.endswith('.safetensors') or model_path.endswith('.bin'):
+                    from huggingface_hub import hf_hub_download
+                    parts = model_path.split('/')
+                    repo_id = f'{parts[0]}/{parts[1]}'
+                    filename = '/'.join(parts[2:])
+                    model = hf_hub_download(repo_id, filename, **self.load_config)
+                    self.model = T2IAdapter.from_pretrained(model, **self.load_config)
+                else:
+                    self.model = T2IAdapter.from_pretrained(model_path, **self.load_config)
+                if self.device is not None:
+                    self.model.to(self.device)
+                if self.dtype is not None:
+                    self.model.to(self.dtype)
+                t1 = time.time()
+                self.model_id = model_id
+                log.debug(f'Control {what} loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
+                return f'{what} loaded model: {model_id}'
+            except Exception as e:
+                log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
+                errors.display(e, f'Control {what} load')
+                return f'{what} failed to load model: {model_id}'


 class AdapterPipeline():
@@ -1,6 +1,7 @@
 import os
 import time
 from typing import Union
+import threading
 from diffusers import StableDiffusionPipeline, StableDiffusionXLPipeline
 from modules.shared import log, opts, listdir
 from modules import errors, sd_models
@@ -23,6 +24,7 @@ all_models = {}
 all_models.update(predefined_sd15)
 all_models.update(predefined_sdxl)
 cache_dir = 'models/control/xs'
+load_lock = threading.Lock()


 def find_models():
@@ -75,42 +77,43 @@ class ControlNetXS():
        self.model_id = None

    def load(self, model_id: str = None, time_embedding_mix: float = 0.0, force: bool = True) -> str:
-        try:
-            t0 = time.time()
-            model_id = model_id or self.model_id
-            if model_id is None or model_id == 'None':
-                self.reset()
-                return
-            if model_id not in all_models:
-                log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
-                return
-            model_path = all_models[model_id]
-            if model_path == '':
-                return
-            if model_path is None:
-                log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
-                return
-            if model_id == self.model_id and not force:
-                # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
-                return
-            self.load_config['time_embedding_mix'] = time_embedding_mix
-            log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}" {self.load_config}')
-            if model_path.endswith('.safetensors'):
-                self.model = ControlNetXSModel.from_single_file(model_path, **self.load_config)
-            else:
-                self.model = ControlNetXSModel.from_pretrained(model_path, **self.load_config)
-            if self.device is not None:
-                self.model.to(self.device)
-            if self.dtype is not None:
-                self.model.to(self.dtype)
-            t1 = time.time()
-            self.model_id = model_id
-            log.debug(f'Control {what} model loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
-            return f'{what} loaded model: {model_id}'
-        except Exception as e:
-            log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
-            errors.display(e, f'Control {what} load')
-            return f'{what} failed to load model: {model_id}'
+        with load_lock:
+            try:
+                t0 = time.time()
+                model_id = model_id or self.model_id
+                if model_id is None or model_id == 'None':
+                    self.reset()
+                    return
+                if model_id not in all_models:
+                    log.error(f'Control {what} unknown model: id="{model_id}" available={list(all_models)}')
+                    return
+                model_path = all_models[model_id]
+                if model_path == '':
+                    return
+                if model_path is None:
+                    log.error(f'Control {what} model load failed: id="{model_id}" error=unknown model id')
+                    return
+                if model_id == self.model_id and not force:
+                    # log.debug(f'Control {what} model: id="{model_id}" path="{model_path}" already loaded')
+                    return
+                self.load_config['time_embedding_mix'] = time_embedding_mix
+                log.debug(f'Control {what} model loading: id="{model_id}" path="{model_path}" {self.load_config}')
+                if model_path.endswith('.safetensors'):
+                    self.model = ControlNetXSModel.from_single_file(model_path, **self.load_config)
+                else:
+                    self.model = ControlNetXSModel.from_pretrained(model_path, **self.load_config)
+                if self.device is not None:
+                    self.model.to(self.device)
+                if self.dtype is not None:
+                    self.model.to(self.dtype)
+                t1 = time.time()
+                self.model_id = model_id
+                log.debug(f'Control {what} model loaded: id="{model_id}" path="{model_path}" time={t1-t0:.2f}')
+                return f'{what} loaded model: {model_id}'
+            except Exception as e:
+                log.error(f'Control {what} model load failed: id="{model_id}" error={e}')
+                errors.display(e, f'Control {what} load')
+                return f'{what} failed to load model: {model_id}'


 class ControlNetXSPipeline():
@@ -1,11 +1,13 @@
 import os
 import re
+import threading
 import torch
 import numpy as np
 from PIL import Image
 from modules import modelloader, paths, deepbooru_model, devices, images, shared

 re_special = re.compile(r'([\\()])')
+load_lock = threading.Lock()


 class DeepDanbooru:
@@ -13,22 +15,23 @@ class DeepDanbooru:
        self.model = None

    def load(self):
-        if self.model is not None:
-            return
-        model_path = os.path.join(paths.models_path, "DeepDanbooru")
-        shared.log.debug(f'Load interrogate model: type=DeepDanbooru folder="{model_path}"')
-        files = modelloader.load_models(
-            model_path=model_path,
-            model_url='https://github.com/AUTOMATIC1111/TorchDeepDanbooru/releases/download/v1/model-resnet_custom_v3.pt',
-            ext_filter=[".pt"],
-            download_name='model-resnet_custom_v3.pt',
-        )
+        with load_lock:
+            if self.model is not None:
+                return
+            model_path = os.path.join(paths.models_path, "DeepDanbooru")
+            shared.log.debug(f'Load interrogate model: type=DeepDanbooru folder="{model_path}"')
+            files = modelloader.load_models(
+                model_path=model_path,
+                model_url='https://github.com/AUTOMATIC1111/TorchDeepDanbooru/releases/download/v1/model-resnet_custom_v3.pt',
+                ext_filter=[".pt"],
+                download_name='model-resnet_custom_v3.pt',
+            )

-        self.model = deepbooru_model.DeepDanbooruModel()
-        self.model.load_state_dict(torch.load(files[0], map_location="cpu"))
+            self.model = deepbooru_model.DeepDanbooruModel()
+            self.model.load_state_dict(torch.load(files[0], map_location="cpu"))

-        self.model.eval()
-        self.model.to(devices.cpu, devices.dtype)
+            self.model.eval()
+            self.model.to(devices.cpu, devices.dtype)

    def start(self):
        self.load()
@@ -3,6 +3,7 @@ import sys
 import time
 from collections import namedtuple
 from pathlib import Path
+import threading
 import re
 import torch
 import torch.hub # pylint: disable=ungrouped-imports
@@ -34,6 +35,7 @@ blip_image_eval_size = 384
 clip_model_name = 'ViT-L/14'
 Category = namedtuple("Category", ["name", "topn", "items"])
 re_topn = re.compile(r"\.top(\d+)\.")
+load_lock = threading.Lock()


 def category_types():
@@ -97,34 +99,35 @@ class InterrogateModels:
        sys.modules["fairscale.nn.checkpoint.checkpoint_activations"] = FakeFairscale

    def load_blip_model(self):
-        self.create_fake_fairscale()
-        from repositories.blip import models # pylint: disable=unused-import
-        from repositories.blip.models import blip
-        import modules.modelloader as modelloader
-        model_path = os.path.join(paths.models_path, "BLIP")
-        download_name='model_base_caption_capfilt_large.pth'
-        shared.log.debug(f'Model interrogate load: type=BLiP model={download_name} path={model_path}')
-        files = modelloader.load_models(
-            model_path=model_path,
-            model_url='https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_caption_capfilt_large.pth',
-            ext_filter=[".pth"],
-            download_name=download_name,
-        )
-        blip_model = blip.blip_decoder(pretrained=files[0], image_size=blip_image_eval_size, vit='base', med_config=os.path.join(paths.paths["BLIP"], "configs", "med_config.json")) # pylint: disable=c-extension-no-member
-        blip_model.eval()
-
-        return blip_model
+        with load_lock:
+            self.create_fake_fairscale()
+            from repositories.blip import models # pylint: disable=unused-import
+            from repositories.blip.models import blip
+            import modules.modelloader as modelloader
+            model_path = os.path.join(paths.models_path, "BLIP")
+            download_name='model_base_caption_capfilt_large.pth'
+            shared.log.debug(f'Model interrogate load: type=BLiP model={download_name} path={model_path}')
+            files = modelloader.load_models(
+                model_path=model_path,
+                model_url='https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_caption_capfilt_large.pth',
+                ext_filter=[".pth"],
+                download_name=download_name,
+            )
+            blip_model = blip.blip_decoder(pretrained=files[0], image_size=blip_image_eval_size, vit='base', med_config=os.path.join(paths.paths["BLIP"], "configs", "med_config.json")) # pylint: disable=c-extension-no-member
+            blip_model.eval()
+            return blip_model

    def load_clip_model(self):
-        shared.log.debug(f'Model interrogate load: type=CLiP model={clip_model_name} path={shared.opts.clip_models_path}')
-        import clip
-        if self.running_on_cpu:
-            model, preprocess = clip.load(clip_model_name, device="cpu", download_root=shared.opts.clip_models_path)
-        else:
-            model, preprocess = clip.load(clip_model_name, download_root=shared.opts.clip_models_path)
-        model.eval()
-        model = model.to(devices.device)
-        return model, preprocess
+        with load_lock:
+            shared.log.debug(f'Model interrogate load: type=CLiP model={clip_model_name} path={shared.opts.clip_models_path}')
+            import clip
+            if self.running_on_cpu:
+                model, preprocess = clip.load(clip_model_name, device="cpu", download_root=shared.opts.clip_models_path)
+            else:
+                model, preprocess = clip.load(clip_model_name, download_root=shared.opts.clip_models_path)
+            model.eval()
+            model = model.to(devices.device)
+            return model, preprocess

    def load(self):
        if self.blip_model is None:
@@ -2,18 +2,20 @@
 import os
 import sys
 import json
+import shlex
 import argparse
 from modules.errors import log


 # parse args, parse again after we have the data-dir and early-read the config file
+argv = shlex.split(" ".join(sys.argv[1:])) if "USED_VSCODE_COMMAND_PICKARGS" in os.environ else sys.argv[1:]
 parser = argparse.ArgumentParser(add_help=False)
 parser.add_argument("--ckpt", type=str, default=os.environ.get("SD_MODEL", None), help="Path to model checkpoint to load immediately, default: %(default)s")
 parser.add_argument("--data-dir", type=str, default=os.environ.get("SD_DATADIR", ''), help="Base path where all user data is stored, default: %(default)s")
 parser.add_argument("--models-dir", type=str, default=os.environ.get("SD_MODELSDIR", None), help="Base path where all models are stored, default: %(default)s",)
-cli = parser.parse_known_args()[0]
-parser.add_argument("--config", type=str, default=os.environ.get("SD_CONFIG", os.path.join(cli.data_dir, 'config.json')), help="Use specific server configuration file, default: %(default)s")
-cli = parser.parse_known_args()[0]
+cli = parser.parse_known_args(argv)[0]
+parser.add_argument("--config", type=str, default=os.environ.get("SD_CONFIG", os.path.join(cli.data_dir, 'config.json')), help="Use specific server configuration file, default: %(default)s") # twice because we want data_dir
+cli = parser.parse_known_args(argv)[0]
 config_path = cli.config if os.path.isabs(cli.config) else os.path.join(cli.data_dir, cli.config)
 try:
    with open(config_path, 'r', encoding='utf8') as f:
@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 import os
+import threading
 from copy import copy
 import numpy as np
 import gradio as gr
@@ -16,6 +17,7 @@ PREDEFINED = [ # <https://huggingface.co/vladmandic/yolo-detailers/tree/main>
    'https://huggingface.co/vladmandic/yolo-detailers/resolve/main/eyes-v1.pt',
    'https://huggingface.co/vladmandic/yolo-detailers/resolve/main/eyes-full-v1.pt',
 ]
+load_lock = threading.Lock()


 class YoloResult:
@@ -151,28 +153,29 @@ class YoloRestorer(Detailer):
        return result

    def load(self, model_name: str = None):
-        from modules import modelloader
-        model = None
-        self.dependencies()
-        if model_name is None:
-            model_name = list(self.list)[0]
-        if model_name in self.models:
-            return model_name, self.models[model_name]
-        else:
-            model_url = self.list.get(model_name)
-            file_name = os.path.basename(model_url)
-            model_file = None
-            try:
-                model_file = modelloader.load_file_from_url(url=model_url, model_dir=shared.opts.yolo_dir, file_name=file_name)
-                if model_file is not None:
-                    import ultralytics
-                    model = ultralytics.YOLO(model_file)
-                    classes = list(model.names.values())
-                    shared.log.info(f'Load: type=Detailer name="{model_name}" model="{model_file}" ultralytics={ultralytics.__version__} classes={classes}')
-                    self.models[model_name] = model
-                    return model_name, model
-            except Exception as e:
-                shared.log.error(f'Load: type=Detailer name="{model_name}" error="{e}"')
+        with load_lock:
+            from modules import modelloader
+            model = None
+            self.dependencies()
+            if model_name is None:
+                model_name = list(self.list)[0]
+            if model_name in self.models:
+                return model_name, self.models[model_name]
+            else:
+                model_url = self.list.get(model_name)
+                file_name = os.path.basename(model_url)
+                model_file = None
+                try:
+                    model_file = modelloader.load_file_from_url(url=model_url, model_dir=shared.opts.yolo_dir, file_name=file_name)
+                    if model_file is not None:
+                        import ultralytics
+                        model = ultralytics.YOLO(model_file)
+                        classes = list(model.names.values())
+                        shared.log.info(f'Load: type=Detailer name="{model_name}" model="{model_file}" ultralytics={ultralytics.__version__} classes={classes}')
+                        self.models[model_name] = model
+                        return model_name, model
+                except Exception as e:
+                    shared.log.error(f'Load: type=Detailer name="{model_name}" error="{e}"')
        return None, None

    def restore(self, np_image, p: processing.StableDiffusionProcessing = None):
@@ -210,6 +210,8 @@ def get_closet_checkpoint_match(s: str):
    if shared.opts.sd_checkpoint_autodownload and s.count('/') == 1:
        modelloader.hf_login()
        found = modelloader.find_diffuser(s, full=True)
+        if found is None:
+            return None
        found = [f for f in found if f == s]
        shared.log.info(f'HF search: model="{s}" results={found}')
        if found is not None and len(found) == 1:
@@ -262,7 +264,7 @@ def select_checkpoint(op='model'):
        shared.log.info(f'Load {op}: select="{checkpoint_info.title if checkpoint_info is not None else None}"')
        return checkpoint_info
    if len(checkpoints_list) == 0:
-        shared.log.warning("Cannot generate without a checkpoint")
+        shared.log.error("No models found")
        shared.log.info("Set system paths to use existing folders")
        shared.log.info("  or use --models-dir <path-to-folder> to specify base folder with all models")
        shared.log.info("  or use --ckpt-dir <path-to-folder> to specify folder with sd models")
@@ -17,7 +17,7 @@
  },
  "scripts": {
    "venv": "source venv/bin/activate",
-    "start": "python launch.py --debug --experimental",
+    "start": "python launch.py --debug",
    "ruff": "ruff check",
    "eslint": "eslint javascript/ extensions-builtin/sdnext-modernui/javascript/",
    "pylint": "pylint *.py modules/ extensions-builtin/",
@@ -2,6 +2,7 @@

 import time
 import random
+import threading
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import gradio as gr
 from modules import shared, scripts, devices, processing
@@ -9,6 +10,7 @@ from modules import shared, scripts, devices, processing

 repo_id = "gokaygokay/Flux-Prompt-Enhance"
 num_return_sequences = 5
+load_lock = threading.Lock()


 class Script(scripts.Script):
@@ -31,11 +33,12 @@ class Script(scripts.Script):
        return shared.native

    def load(self):
-        if self.tokenizer is None:
-            self.tokenizer = AutoTokenizer.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir)
-        if self.model is None:
-            shared.log.info(f'Prompt enhance: model="{repo_id}"')
-            self.model = AutoModelForSeq2SeqLM.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir).to(device=devices.cpu, dtype=devices.dtype)
+        with load_lock:
+            if self.tokenizer is None:
+                self.tokenizer = AutoTokenizer.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir)
+            if self.model is None:
+                shared.log.info(f'Prompt enhance: model="{repo_id}"')
+                self.model = AutoModelForSeq2SeqLM.from_pretrained('gokaygokay/Flux-Prompt-Enhance', cache_dir=shared.opts.hfcache_dir).to(device=devices.cpu, dtype=devices.dtype)

    def enhance(self, prompt, auto_apply: bool = False, temperature: float = 0.7, repetition_penalty: float = 1.2, max_length: int = 128):
        self.load()