eliminate possible race conditions during startup

Signed-off-by: vladmandic <mandic00@live.com>

installer.py

@@ -110,6 +110,13 @@ def print_dict(d):
     return ' '.join([f'{k}={v}' for k, v in d.items()])
 
 
+def env_flag(name: str, default: bool = False) -> bool:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    return str(value).strip().lower() in ('1', 'true', 'yes', 'on')
+
+
 def print_profile(profiler: cProfile.Profile, msg: str):
     profiler.disable()
     from modules.errors import profile
@@ -1256,7 +1263,6 @@ def get_version(force=False):
                 log.warning('Version: detached state detected')
         except Exception as e:
             log.warning(f'Version: where=branch {e}')
-        cwd = os.getcwd()
         try:
             if os.path.exists('extensions-builtin/sdnext-modernui'):
                 res = subprocess.run('git rev-parse --abbrev-ref HEAD', capture_output=True, shell=True, check=True, cwd='extensions-builtin/sdnext-modernui')
@@ -1268,8 +1274,6 @@ def get_version(force=False):
         except Exception as e:
             log.warning(f'Version: where=modernui {e}')
             version['ui'] = 'unknown'
-        finally:
-            os.chdir(cwd)
         try:
             if os.environ.get('SD_KANVAS_DISABLE', None) is not None:
                 version['kanvas'] = 'disabled'
@@ -1283,8 +1287,6 @@ def get_version(force=False):
         except Exception as e:
             log.warning(f'Version: where=kanvas {e}')
             version['kanvas'] = 'unknown'
-        finally:
-            os.chdir(cwd)
     ts('version', t_start)
     return version
 
@@ -1298,17 +1300,13 @@ def check_ui(ver):
     t_start = time.time()
     if not same(ver):
         log.debug(f'Branch mismatch: {ver}')
-        cwd = os.getcwd()
         try:
-            os.chdir('extensions-builtin/sdnext-modernui')
             target = 'dev' if 'dev' in ver['branch'] else 'main'
-            git('checkout ' + target, ignore=True, optional=True)
+            git('checkout ' + target, folder='extensions-builtin/sdnext-modernui', ignore=True, optional=True)
-            os.chdir(cwd)
             ver = get_version(force=True)
             log.debug(f'Branch sync: {ver}')
         except Exception as e:
             log.debug(f'Branch switch: {e}')
-        os.chdir(cwd)
     ts('ui', t_start)
 
 
@@ -1431,30 +1429,6 @@ def update_wiki():
     ts('wiki', t_start)
 
 
-def run_deferred_tasks():
-    t_start = time.time()
-    log.debug('Starting deferred tasks')
-    time.sleep(1.0) # wait for server to start
-    try:
-        from modules.sd_checkpoint import write_metadata
-        write_metadata()
-    except Exception as e:
-        log.error(f'Deferred task error: write_metadata {e}')
-    try:
-        check_version()
-    except Exception as e:
-        log.error(f'Deferred task error: check_version {e}')
-    try:
-        check_modified_files()
-    except Exception as e:
-        log.error(f'Deferred task error: check_modified_files {e}')
-    try:
-        update_wiki()
-    except Exception as e:
-        log.error(f'Deferred task error: update_wiki {e}')
-    log.debug(f'Deferred tasks complete: time={round(time.time() - t_start, 2)}')
-
-
 @lru_cache
 def get_state():
     state = {
@@ -1540,19 +1514,19 @@ def check_timestamp():
 
 def add_args(parser):
     group_install = parser.add_argument_group('Install')
-    group_install.add_argument('--quick', default=os.environ.get("SD_QUICK",False), action='store_true', help="Bypass version checks, default: %(default)s")
+    group_install.add_argument('--quick', default=env_flag("SD_QUICK", False), action='store_true', help="Bypass version checks, default: %(default)s")
-    group_install.add_argument('--reset', default=os.environ.get("SD_RESET",False), action='store_true', help="Reset main repository to latest version, default: %(default)s")
+    group_install.add_argument('--reset', default=env_flag("SD_RESET", False), action='store_true', help="Reset main repository to latest version, default: %(default)s")
-    group_install.add_argument('--upgrade', '--update', default=os.environ.get("SD_UPGRADE",False), action='store_true', help="Upgrade main repository to latest version, default: %(default)s")
+    group_install.add_argument('--upgrade', '--update', default=env_flag("SD_UPGRADE", False), action='store_true', help="Upgrade main repository to latest version, default: %(default)s")
-    group_install.add_argument('--requirements', default=os.environ.get("SD_REQUIREMENTS",False), action='store_true', help="Force re-check of requirements, default: %(default)s")
+    group_install.add_argument('--requirements', default=env_flag("SD_REQUIREMENTS", False), action='store_true', help="Force re-check of requirements, default: %(default)s")
-    group_install.add_argument('--reinstall', default=os.environ.get("SD_REINSTALL",False), action='store_true', help="Force reinstallation of all requirements, default: %(default)s")
+    group_install.add_argument('--reinstall', default=env_flag("SD_REINSTALL", False), action='store_true', help="Force reinstallation of all requirements, default: %(default)s")
-    group_install.add_argument('--uv', default=os.environ.get("SD_UV",False), action='store_true', help="Use uv instead of pip to install the packages")
+    group_install.add_argument('--uv', default=env_flag("SD_UV", False), action='store_true', help="Use uv instead of pip to install the packages")
-    group_install.add_argument('--optional', default=os.environ.get("SD_OPTIONAL",False), action='store_true', help="Force installation of optional requirements, default: %(default)s")
+    group_install.add_argument('--optional', default=env_flag("SD_OPTIONAL", False), action='store_true', help="Force installation of optional requirements, default: %(default)s")
-    group_install.add_argument('--skip-requirements', default=os.environ.get("SD_SKIPREQUIREMENTS",False), action='store_true', help="Skips checking and installing requirements, default: %(default)s")
+    group_install.add_argument('--skip-requirements', default=env_flag("SD_SKIPREQUIREMENTS", False), action='store_true', help="Skips checking and installing requirements, default: %(default)s")
-    group_install.add_argument('--skip-extensions', default=os.environ.get("SD_SKIPEXTENSION",False), action='store_true', help="Skips running individual extension installers, default: %(default)s")
+    group_install.add_argument('--skip-extensions', default=env_flag("SD_SKIPEXTENSION", False), action='store_true', help="Skips running individual extension installers, default: %(default)s")
-    group_install.add_argument('--skip-git', default=os.environ.get("SD_SKIPGIT",False), action='store_true', help="Skips running all GIT operations, default: %(default)s")
+    group_install.add_argument('--skip-git', default=env_flag("SD_SKIPGIT", False), action='store_true', help="Skips running all GIT operations, default: %(default)s")
-    group_install.add_argument('--skip-torch', default=os.environ.get("SD_SKIPTORCH",False), action='store_true', help="Skips running Torch checks, default: %(default)s")
+    group_install.add_argument('--skip-torch', default=env_flag("SD_SKIPTORCH", False), action='store_true', help="Skips running Torch checks, default: %(default)s")
-    group_install.add_argument('--skip-all', default=os.environ.get("SD_SKIPALL",False), action='store_true', help="Skips running all checks, default: %(default)s")
+    group_install.add_argument('--skip-all', default=env_flag("SD_SKIPALL", False), action='store_true', help="Skips running all checks, default: %(default)s")
-    group_install.add_argument('--skip-env', default=os.environ.get("SD_SKIPENV",False), action='store_true', help="Skips setting of env variables during startup, default: %(default)s")
+    group_install.add_argument('--skip-env', default=env_flag("SD_SKIPENV", False), action='store_true', help="Skips setting of env variables during startup, default: %(default)s")
 
 
 def parse_args(parser):

launch.py

@@ -5,7 +5,6 @@ import os
 import sys
 import time
 import shlex
-import threading
 import subprocess
 
 import installer
@@ -211,7 +210,6 @@ def start_server(immediate=True, server=None):
     server = importlib.util.module_from_spec(module_spec)
     log.debug(f'Starting module: {server}')
     module_spec.loader.exec_module(server)
-    threading.Thread(target=installer.run_deferred_tasks, daemon=True).start()
 
     uvicorn = None
     if args.test:
@@ -252,9 +250,10 @@ def main():
     if args.skip_git or args.skip_all:
         log.info('Skipping GIT operations')
     log.info(f'Platform: {installer.print_dict(installer.get_platform())}')
+    installer.check_version()
     installer.check_venv()
     log.info(f'Args: {sys.argv[1:]}')
-    if not args.skip_env or args.skip_all:
+    if not args.skip_env and not args.skip_all:
         installer.set_environment()
     if args.uv:
         installer.install('uv', 'uv')
@@ -263,6 +262,7 @@ def main():
     installer.check_onnx()
     installer.check_transformers()
     installer.check_diffusers()
+    installer.check_modified_files()
     if args.test:
         log.info('Startup: mode=test')
         installer.quick_allowed = False
@@ -295,6 +295,7 @@ def main():
     args = installer.parse_args(parser)
     log.info(f'Installer time: {init_summary()}')
     get_custom_args()
+    installer.update_wiki()
 
     uv, instance = start_server(immediate=True, server=None)
     if installer.restart_required:

modules/cmd_args.py

@@ -4,6 +4,13 @@ import argparse
 import shlex
 
 
+def env_flag(name, default=False):
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    return str(value).strip().lower() in ('1', 'true', 'yes', 'on')
+
+
 def get_argv():
     return shlex.split(" ".join(sys.argv[1:])) if "USED_VSCODE_COMMAND_PICKARGS" in os.environ else sys.argv[1:]
 
@@ -25,18 +32,18 @@ def add_config_arg(p, data_dir):
 
 def add_compute_args(p):
     p.add_argument("--device-id", type=str, default=os.environ.get("SD_DEVICEID", None), help="Select the default GPU device to use, default: %(default)s")
-    p.add_argument("--use-cuda", default=os.environ.get("SD_USECUDA", False), action='store_true', help="Force use nVidia CUDA backend, default: %(default)s")
+    p.add_argument("--use-cuda", default=env_flag("SD_USECUDA", False), action='store_true', help="Force use nVidia CUDA backend, default: %(default)s")
-    p.add_argument("--use-ipex", default=os.environ.get("SD_USEIPEX", False), action='store_true', help="Force use Intel OneAPI XPU backend, default: %(default)s")
+    p.add_argument("--use-ipex", default=env_flag("SD_USEIPEX", False), action='store_true', help="Force use Intel OneAPI XPU backend, default: %(default)s")
-    p.add_argument("--use-rocm", default=os.environ.get("SD_USEROCM", False), action='store_true', help="Force use AMD ROCm backend, default: %(default)s")
+    p.add_argument("--use-rocm", default=env_flag("SD_USEROCM", False), action='store_true', help="Force use AMD ROCm backend, default: %(default)s")
-    p.add_argument('--use-zluda', default=os.environ.get("SD_USEZLUDA", False), action='store_true', help="Force use ZLUDA, AMD GPUs only, default: %(default)s")
+    p.add_argument('--use-zluda', default=env_flag("SD_USEZLUDA", False), action='store_true', help="Force use ZLUDA, AMD GPUs only, default: %(default)s")
-    p.add_argument("--use-openvino", default=os.environ.get("SD_USEOPENVINO", False), action='store_true', help="Use Intel OpenVINO backend, default: %(default)s")
+    p.add_argument("--use-openvino", default=env_flag("SD_USEOPENVINO", False), action='store_true', help="Use Intel OpenVINO backend, default: %(default)s")
-    p.add_argument('--use-directml', default=os.environ.get("SD_USEDIRECTML", False), action='store_true', help="Use DirectML if no compatible GPU is detected, default: %(default)s")
+    p.add_argument('--use-directml', default=env_flag("SD_USEDIRECTML", False), action='store_true', help="Use DirectML if no compatible GPU is detected, default: %(default)s")
-    p.add_argument("--use-xformers", default=os.environ.get("SD_USEXFORMERS", False), action='store_true', help="Force use xFormers cross-optimization, default: %(default)s")
+    p.add_argument("--use-xformers", default=env_flag("SD_USEXFORMERS", False), action='store_true', help="Force use xFormers cross-optimization, default: %(default)s")
-    p.add_argument("--use-nightly", default=os.environ.get("SD_USENIGHTLY", False), action='store_true', help="Force use nightly torch builds, default: %(default)s")
+    p.add_argument("--use-nightly", default=env_flag("SD_USENIGHTLY", False), action='store_true', help="Force use nightly torch builds, default: %(default)s")
-    p.add_argument("--no-half", default=os.environ.get("SD_NOHALF", False), action='store_true', help="Do not switch the model to 16-bit float, default: %(default)s")
+    p.add_argument("--no-half", default=env_flag("SD_NOHALF", False), action='store_true', help="Do not switch the model to 16-bit float, default: %(default)s")
-    p.add_argument("--no-half-vae", default=os.environ.get("SD_NOHALFVAE", False), action='store_true', help="Do not switch VAE model to 16-bit float, default: %(default)s")
+    p.add_argument("--no-half-vae", default=env_flag("SD_NOHALFVAE", False), action='store_true', help="Do not switch VAE model to 16-bit float, default: %(default)s")
     p.add_argument("--precision", type=str, help="Evaluate at this precision, default: %(default)s", choices=["full", "autocast"], default="autocast")
-    p.add_argument("--upcast-sampling", default=os.environ.get("SD_UPCASTSAMPLING", False), action='store_true', help="Upcast sampling, default: %(default)s")
+    p.add_argument("--upcast-sampling", default=env_flag("SD_UPCASTSAMPLING", False), action='store_true', help="Upcast sampling, default: %(default)s")
 
 
 def add_ui_args(p):
@@ -48,27 +55,27 @@ def add_http_args(p):
     p.add_argument("--server-name", type=str, default=os.environ.get("SD_SERVERNAME", None), help="Sets hostname of server, default: %(default)s")
     p.add_argument("--tls-keyfile", type=str, default=os.environ.get("SD_TLSKEYFILE", None), help="Enable TLS and specify key file, default: %(default)s")
     p.add_argument("--tls-certfile", type=str, default=os.environ.get("SD_TLSCERTFILE", None), help="Enable TLS and specify cert file, default: %(default)s")
-    p.add_argument("--tls-selfsign", action="store_true", default=os.environ.get("SD_TLSSELFSIGN", False), help="Enable TLS with self-signed certificates, default: %(default)s")
+    p.add_argument("--tls-selfsign", action="store_true", default=env_flag("SD_TLSSELFSIGN", False), help="Enable TLS with self-signed certificates, default: %(default)s")
     p.add_argument("--cors-origins", type=str, default=os.environ.get("SD_CORSORIGINS", None), help="Allowed CORS origins as comma-separated list, default: %(default)s")
     p.add_argument("--cors-regex", type=str, default=os.environ.get("SD_CORSREGEX", None), help="Allowed CORS origins as regular expression, default: %(default)s")
     p.add_argument('--subpath', type=str, default=os.environ.get("SD_SUBPATH", None), help='Customize the URL subpath for usage with reverse proxy')
-    p.add_argument("--autolaunch", default=os.environ.get("SD_AUTOLAUNCH", False), action='store_true', help="Open the UI URL in the system's default browser upon launch")
+    p.add_argument("--autolaunch", default=env_flag("SD_AUTOLAUNCH", False), action='store_true', help="Open the UI URL in the system's default browser upon launch")
     p.add_argument("--auth", type=str, default=os.environ.get("SD_AUTH", None), help='Set access authentication like "user:pwd,user:pwd""')
     p.add_argument("--auth-file", type=str, default=os.environ.get("SD_AUTHFILE", None), help='Set access authentication using file, default: %(default)s')
     p.add_argument("--allowed-paths", nargs='+', default=[], type=str, required=False, help="add additional paths to paths allowed for web access")
-    p.add_argument("--share", default=os.environ.get("SD_SHARE", False), action='store_true', help="Enable UI accessible through Gradio site, default: %(default)s")
+    p.add_argument("--share", default=env_flag("SD_SHARE", False), action='store_true', help="Enable UI accessible through Gradio site, default: %(default)s")
-    p.add_argument("--insecure", default=os.environ.get("SD_INSECURE", False), action='store_true', help="Enable extensions tab regardless of other options, default: %(default)s")
+    p.add_argument("--insecure", default=env_flag("SD_INSECURE", False), action='store_true', help="Enable extensions tab regardless of other options, default: %(default)s")
-    p.add_argument("--listen", default=os.environ.get("SD_LISTEN", False), action='store_true', help="Launch web server using public IP address, default: %(default)s")
+    p.add_argument("--listen", default=env_flag("SD_LISTEN", False), action='store_true', help="Launch web server using public IP address, default: %(default)s")
-    p.add_argument("--remote", default=os.environ.get("SD_REMOTE", False), action='store_true', help="Reduce client-server communication, default: %(default)s")
+    p.add_argument("--remote", default=env_flag("SD_REMOTE", False), action='store_true', help="Reduce client-server communication, default: %(default)s")
     p.add_argument("--port", type=int, default=os.environ.get("SD_PORT", 7860), help="Launch web server with given server port, default: %(default)s")
 
 
 def add_diag_args(p):
-    p.add_argument('--experimental', default=os.environ.get("SD_EXPERIMENTAL", False), action='store_true', help="Allow unsupported versions of libraries, default: %(default)s")
+    p.add_argument('--experimental', default=env_flag("SD_EXPERIMENTAL", False), action='store_true', help="Allow unsupported versions of libraries, default: %(default)s")
-    p.add_argument('--ignore', default=os.environ.get("SD_IGNORE", False), action='store_true', help="Ignore any errors and attempt to continue")
+    p.add_argument('--ignore', default=env_flag("SD_IGNORE", False), action='store_true', help="Ignore any errors and attempt to continue")
-    p.add_argument('--new', default=os.environ.get("SD_NEW", False), action='store_true', help="Force newer/untested version of libraries, default: %(default)s")
+    p.add_argument('--new', default=env_flag("SD_NEW", False), action='store_true', help="Force newer/untested version of libraries, default: %(default)s")
-    p.add_argument('--safe', default=os.environ.get("SD_SAFE", False), action='store_true', help="Run in safe mode with no user extensions")
+    p.add_argument('--safe', default=env_flag("SD_SAFE", False), action='store_true', help="Run in safe mode with no user extensions")
-    p.add_argument('--test', default=os.environ.get("SD_TEST", False), action='store_true', help="Run test only and exit")
+    p.add_argument('--test', default=env_flag("SD_TEST", False), action='store_true', help="Run test only and exit")
     p.add_argument('--version', default=False, action='store_true', help="Print version information")
     p.add_argument("--monitor", default=os.environ.get("SD_MONITOR", 0), help="Run memory monitor, default: %(default)s")
     p.add_argument("--status", default=os.environ.get("SD_STATUS", 120), help="Run server is-alive status, default: %(default)s")
@@ -76,11 +83,11 @@ def add_diag_args(p):
 
 def add_log_args(p):
     p.add_argument("--log", type=str, default=os.environ.get("SD_LOG", None), help="Set log file, default: %(default)s")
-    p.add_argument('--debug', default=not os.environ.get("SD_NODEBUG", False), action='store_true', help="Run with debug logging, default: %(default)s")
+    p.add_argument('--debug', default=not env_flag("SD_NODEBUG", False), action='store_true', help="Run with debug logging, default: %(default)s")
-    p.add_argument("--trace", default=os.environ.get("SD_TRACE", False), action='store_true', help="Run with trace logging, default: %(default)s")
+    p.add_argument("--trace", default=env_flag("SD_TRACE", False), action='store_true', help="Run with trace logging, default: %(default)s")
-    p.add_argument("--profile", default=os.environ.get("SD_PROFILE", False), action='store_true', help="Run profiler, default: %(default)s")
+    p.add_argument("--profile", default=env_flag("SD_PROFILE", False), action='store_true', help="Run profiler, default: %(default)s")
-    p.add_argument('--docs', default=not os.environ.get("SD_NODOCS", False), action='store_true', help="Mount API docs, default: %(default)s")
+    p.add_argument('--docs', default=not env_flag("SD_NODOCS", False), action='store_true', help="Mount API docs, default: %(default)s")
-    p.add_argument("--api-log", default=not os.environ.get("SD_NOAPILOG", False), action='store_true', help="Log all API requests")
+    p.add_argument("--api-log", default=not env_flag("SD_NOAPILOG", False), action='store_true', help="Log all API requests")
 
 
 parsed = None
@@ -134,8 +141,8 @@ def compatibility_args():
     from modules.paths import data_path
     group_compat = parser.add_argument_group('Compatibility options')
     group_compat.add_argument('--backend', type=str, choices=['diffusers', 'original'], help=argparse.SUPPRESS)
-    group_compat.add_argument("--allow-code", default=os.environ.get("SD_ALLOWCODE", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--allow-code", default=env_flag("SD_ALLOWCODE", False), action='store_true', help=argparse.SUPPRESS)
-    group_compat.add_argument("--enable_insecure_extension_access", default=os.environ.get("SD_INSECURE", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--enable_insecure_extension_access", default=env_flag("SD_INSECURE", False), action='store_true', help=argparse.SUPPRESS)
     group_compat.add_argument("--use-cpu", nargs='+', default=[], type=str.lower, help=argparse.SUPPRESS)
     group_compat.add_argument("-f", action='store_true', help=argparse.SUPPRESS)  # allows running as root; implemented outside of webui
     group_compat.add_argument('--vae', type=str, default=os.environ.get("SD_VAE", None), help=argparse.SUPPRESS)
@@ -149,16 +156,16 @@ def compatibility_args():
     group_compat.add_argument("--api", action='store_true', help=argparse.SUPPRESS, default=True)
     group_compat.add_argument("--api-auth", type=str, help=argparse.SUPPRESS, default=None)
     group_compat.add_argument('--api-only', default=False, help=argparse.SUPPRESS)
-    group_compat.add_argument("--disable-queue", default=os.environ.get("SD_DISABLEQUEUE", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--disable-queue", default=env_flag("SD_DISABLEQUEUE", False), action='store_true', help=argparse.SUPPRESS)
-    group_compat.add_argument("--no-hashing", default=os.environ.get("SD_NOHASHING", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--no-hashing", default=env_flag("SD_NOHASHING", False), action='store_true', help=argparse.SUPPRESS)
-    group_compat.add_argument("--no-metadata", default=os.environ.get("SD_NOMETADATA", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--no-metadata", default=env_flag("SD_NOMETADATA", False), action='store_true', help=argparse.SUPPRESS)
 
 
 def settings_args(opts, args):
     # removed args are added here as hidden in fixed format for compatbility reasons
     from modules.paths import data_path
     group_compat = parser.add_argument_group('Compatibility options')
-    group_compat.add_argument("--allow-code", default=os.environ.get("SD_ALLOWCODE", False), action='store_true', help=argparse.SUPPRESS)
+    group_compat.add_argument("--allow-code", default=env_flag("SD_ALLOWCODE", False), action='store_true', help=argparse.SUPPRESS)
     group_compat.add_argument("--use-cpu", nargs='+', default=[], type=str.lower, help=argparse.SUPPRESS)
     group_compat.add_argument("-f", action='store_true', help=argparse.SUPPRESS)  # allows running as root; implemented outside of webui
     group_compat.add_argument('--vae', type=str, default=os.environ.get("SD_VAE", None), help=argparse.SUPPRESS)

modules/json_helpers.py

@@ -74,7 +74,7 @@ def readfile(filename: str, silent: bool = False, lock: bool = False, *, as_type
     return data
 
 
-def writefile(data, filename, mode='w', silent=False, atomic=False):
+def writefile(obj, filename, mode='w', silent=False, atomic=False):
     import tempfile
     global locking_available # pylint: disable=global-statement
     lock_file = None
@@ -86,6 +86,7 @@ def writefile(data, filename, mode='w', silent=False, atomic=False):
 
     try:
         t0 = time.time()
+        data = obj.copy()
         # skipkeys=True, ensure_ascii=True, check_circular=True, allow_nan=True
         if type(data) == dict:
             output = json.dumps(data, indent=2, default=default)

webui.py

@@ -92,6 +92,8 @@ def initialize():
     def _scan_models():
         modules.modelloader.cleanup_models()
         modules.sd_checkpoint.setup_model()
+        from modules.sd_checkpoint import write_metadata
+        write_metadata()
     def _scan_lora():
         from modules.lora import lora_load
         lora_load.list_available_networks()
@@ -300,6 +302,16 @@ def start_ui():
                     gradio_auth_creds += [x.strip() for x in line.split(',') if x.strip()]
     if len(gradio_auth_creds) > 0:
         log.info(f'Authentication enabled: users={len(list(gradio_auth_creds))}')
+    auth_pairs = []
+    for cred in gradio_auth_creds:
+        if ':' not in cred:
+            log.warning(f'Ignoring malformed auth entry: "{cred}"')
+            continue
+        user, password = cred.split(':', 1)
+        if len(user) == 0 or len(password) == 0:
+            log.warning(f'Ignoring malformed auth entry: "{cred}"')
+            continue
+        auth_pairs.append((user, password))
 
     global local_url # pylint: disable=global-statement
     stdout = io.StringIO()
@@ -320,7 +332,7 @@ def start_ui():
             ssl_certfile=shared.cmd_opts.tls_certfile,
             ssl_verify=not shared.cmd_opts.tls_selfsign,
             debug=False,
-            auth=[tuple(cred.split(':')) for cred in gradio_auth_creds] if gradio_auth_creds else None,
+            auth=auth_pairs if auth_pairs else None,
             prevent_thread_lock=True,
             max_threads=64,
             show_api=False,

webui.sh

@@ -99,11 +99,11 @@ then
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/rocm/lib
 fi
 
-if [[ ! -z "${ACCELERATE}" ]] && [ ${ACCELERATE}="True" ] && [ -x "$(command -v accelerate)" ]
+if [[ -n "${ACCELERATE}" ]] && [[ "${ACCELERATE}" == "True" ]] && [ -x "$(command -v accelerate)" ]
 then
     echo "Launch: accelerate"
     exec accelerate launch --num_cpu_threads_per_process=6 launch.py "$@"
-elif [[ ! -z "${IPEXRUN}" ]] && [ ${IPEXRUN}="True" ] && [ -x "$(command -v ipexrun)" ]
+elif [[ -n "${IPEXRUN}" ]] && [[ "${IPEXRUN}" == "True" ]] && [ -x "$(command -v ipexrun)" ]
 then
     echo "Launch: ipexrun"
     exec ipexrun --multi-task-manager 'taskset' --memory-allocator 'jemalloc' launch.py "$@"