Repository: stable-diffusion-webui
Issue: [Bug]: Error when running web-user.bat
Labels: bug-report

### Is there an existing issue for this?

- [X] I have searched the existing issues and checked the recent builds/commits

### What happened?

UI does not launch.

### Steps to reproduce the problem

1. ran webui-user.bat

### What should have happened?

ui should launch

### Version or Commit where the problem happens

1.4.0

### What Python version are you running on ?

Python 3.10.x

### What platforms do you use to access the UI ?

Windows

### What device are you running WebUI on?

Nvidia GPUs (RTX 20 above)

### Cross attention optimization

Automatic

### What browsers do you use to access the UI ?

Google Chrome

### Command Line Arguments

```Shell
--xformers --autolaunch --theme dark
```


### List of extensions

adetailer
gif2gif
sd-web-ui-addition-networks
sd-web-ui-infintie-image-browsing

### Console logs

```Shell
│ E:\SD\stable-diffusion-webui\launch.py:38 in <module>                                            │
│                                                                                                  │
│   35                                                                                             │
│   36                                                                                             │
│   37 if __name__ == "__main__":                                                                  │
│ ❱ 38 │   main()                                                                                  │
│   39                                                                                             │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\launch.py:34 in main                                                │
│                                                                                                  │
│   31 │   if args.test_server:                                                                    │
│   32 │   │   configure_for_tests()                                                               │
│   33 │                                                                                           │
│ ❱ 34 │   start()                                                                                 │
│   35                                                                                             │
│   36                                                                                             │
│   37 if __name__ == "__main__":                                                                  │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\modules\launch_utils.py:344 in start                                │
│                                                                                                  │
│   341 │   if '--nowebui' in sys.argv:                                                            │
│   342 │   │   webui.api_only()                                                                   │
│   343 │   else:                                                                                  │
│ ❱ 344 │   │   webui.webui()                                                                      │
│   345                                                                                            │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\webui.py:372 in webui                                               │
│                                                                                                  │
│   369                                                                                            │
│   370 def webui():                                                                               │
│   371 │   launch_api = cmd_opts.api                                                              │
│ ❱ 372 │   initialize()                                                                           │
│   373 │                                                                                          │
│   374 │   while 1:                                                                               │
│   375 │   │   if shared.opts.clean_temp_dir_at_start:                                            │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\webui.py:252 in initialize                                          │
│                                                                                                  │
│   249 │   gfpgan.setup_model(cmd_opts.gfpgan_models_path)                                        │
│   250 │   startup_timer.record("setup gfpgan")                                                   │
│   251 │                                                                                          │
│ ❱ 252 │   initialize_rest(reload_script_modules=False)                                           │
│   253                                                                                            │
│   254                                                                                            │
│   255 def initialize_rest(*, reload_script_modules=False):                                       │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\webui.py:270 in initialize_rest                                     │
│                                                                                                  │
│   267 │   │   modules.scripts.load_scripts()                                                     │
│   268 │   │   return                                                                             │
│   269 │                                                                                          │
│ ❱ 270 │   modules.sd_models.list_models()                                                        │
│   271 │   startup_timer.record("list SD models")                                                 │
│   272 │                                                                                          │
│   273 │   localization.list_localizations(cmd_opts.localizations_dir)                            │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\modules\sd_models.py:134 in list_models                             │
│                                                                                                  │
│   131 │   │   print(f"Checkpoint in --ckpt argument not found (Possible it was moved to {model   │
│   132 │                                                                                          │
│   133 │   for filename in sorted(model_list, key=str.lower):                                     │
│ ❱ 134 │   │   checkpoint_info = CheckpointInfo(filename)                                         │
│   135 │   │   checkpoint_info.register()                                                         │
│   136                                                                                            │
│   137                                                                                            │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\modules\sd_models.py:50 in __init__                                 │
│                                                                                                  │
│    47 │   │   self.model_name = os.path.splitext(name.replace("/", "_").replace("\\", "_"))[0]   │
│    48 │   │   self.hash = model_hash(filename)                                                   │
│    49 │   │                                                                                      │
│ ❱  50 │   │   self.sha256 = hashes.sha256_from_cache(self.filename, f"checkpoint/{name}")        │
│    51 │   │   self.shorthash = self.sha256[0:10] if self.sha256 else None                        │
│    52 │   │                                                                                      │
│    53 │   │   self.title = name if self.shorthash is None else f'{name} [{self.shorthash}]'      │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\modules\hashes.py:50 in sha256_from_cache                           │
│                                                                                                  │
│    47                                                                                            │
│    48                                                                                            │
│    49 def sha256_from_cache(filename, title, use_addnet_hash=False):                             │
│ ❱  50 │   hashes = cache("hashes-addnet") if use_addnet_hash else cache("hashes")                │
│    51 │   ondisk_mtime = os.path.getmtime(filename)                                              │
│    52 │                                                                                          │
│    53 │   if title not in hashes:                                                                │
│                                                                                                  │
│ E:\SD\stable-diffusion-webui\modules\hashes.py:30 in cache                                       │
│                                                                                                  │
│    27 │   │   │   │   cache_data = {}                                                            │
│    28 │   │   │   else:                                                                          │
│    29 │   │   │   │   with open(cache_filename, "r", encoding="utf8") as file:                   │
│ ❱  30 │   │   │   │   │   cache_data = json.load(file)                                           │
│    31 │                                                                                          │
│    32 │   s = cache_data.get(subsection, {})                                                     │
│    33 │   cache_data[subsection] = s                                                             │
│                                                                                                  │
│ C:\Users\dialm\AppData\Local\Programs\Python\Python310\lib\json\__init__.py:293 in load          │
│                                                                                                  │
│   290 │   To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``                  │
│   291 │   kwarg; otherwise ``JSONDecoder`` is used.                                              │
│   292 │   """                                                                                    │
│ ❱ 293 │   return loads(fp.read(),                                                                │
│   294 │   │   cls=cls, object_hook=object_hook,                                                  │
│   295 │   │   parse_float=parse_float, parse_int=parse_int,                                      │
│   296 │   │   parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)          │
│                                                                                                  │
│ C:\Users\dialm\AppData\Local\Programs\Python\Python310\lib\json\__init__.py:346 in loads         │
│                                                                                                  │
│   343 │   if (cls is None and object_hook is None and                                            │
│   344 │   │   │   parse_int is None and parse_float is None and                                  │
│   345 │   │   │   parse_constant is None and object_pairs_hook is None and not kw):              │
│ ❱ 346 │   │   return _default_decoder.decode(s)                                                  │
│   347 │   if cls is None:                                                                        │
│   348 │   │   cls = JSONDecoder                                                                  │
│   349 │   if object_hook is not None:                                                            │
│                                                                                                  │
│ C:\Users\dialm\AppData\Local\Programs\Python\Python310\lib\json\decoder.py:337 in decode         │
│                                                                                                  │
│   334 │   │   containing a JSON document).                                                       │
│   335 │   │                                                                                      │
│   336 │   │   """                                                                                │
│ ❱ 337 │   │   obj, end = self.raw_decode(s, idx=_w(s, 0).end())                                  │
│   338 │   │   end = _w(s, end).end()                                                             │
│   339 │   │   if end != len(s):                                                                  │
│   340 │   │   │   raise JSONDecodeError("Extra data", s, end)                                    │
│                                                                                                  │
│ C:\Users\dialm\AppData\Local\Programs\Python\Python310\lib\json\decoder.py:355 in raw_decode     │
│                                                                                                  │
│   352 │   │   try:                                                                               │
│   353 │   │   │   obj, end = self.scan_once(s, idx)                                              │
│   354 │   │   except StopIteration as err:                                                       │
│ ❱ 355 │   │   │   raise JSONDecodeError("Expecting value", s, err.value) from None               │
│   356 │   │   return obj, end                                                                    │
│   357
```


### Additional information

_No response_