import sys import textwrap import traceback exception_records = [] def format_traceback(tb): return [[f"{x.filename}, line {x.lineno}, {x.name}", x.line] for x in traceback.extract_tb(tb)] def format_exception(e, tb): return {"exception": str(e), "traceback": format_traceback(tb)} def get_exceptions(): try: return list(reversed(exception_records)) except Exception as e: return str(e) def record_exception(): _, e, tb = sys.exc_info() if e is None: return if exception_records and exception_records[-1] == e: return exception_records.append(format_exception(e, tb)) if len(exception_records) > 5: exception_records.pop(0) def report(message: str, *, exc_info: bool = False) -> None: """ Print an error message to stderr, with optional traceback. """ record_exception() for line in message.splitlines(): print("***", line, file=sys.stderr) if exc_info: print(textwrap.indent(traceback.format_exc(), " "), file=sys.stderr) print("---", file=sys.stderr) def print_error_explanation(message): record_exception() lines = message.strip().split("\n") max_len = max([len(x) for x in lines]) print('=' * max_len, file=sys.stderr) for line in lines: print(line, file=sys.stderr) print('=' * max_len, file=sys.stderr) def display(e: Exception, task, *, full_traceback=False): record_exception() print(f"{task or 'error'}: {type(e).__name__}", file=sys.stderr) te = traceback.TracebackException.from_exception(e) if full_traceback: # include frames leading up to the try-catch block te.stack = traceback.StackSummary(traceback.extract_stack()[:-2] + te.stack) print(*te.format(), sep="", file=sys.stderr) message = str(e) if "copying a param with shape torch.Size([640, 1024]) from checkpoint, the shape in current model is torch.Size([640, 768])" in message: print_error_explanation(""" The most likely cause of this is you are trying to load Stable Diffusion 2.0 model without specifying its config file. See https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Features#stable-diffusion-20 for how to solve this. """) already_displayed = {} def display_once(e: Exception, task): record_exception() if task in already_displayed: return display(e, task) already_displayed[task] = 1 def run(code, task): try: code() except Exception as e: display(task, e) def check_versions(): from packaging import version from modules import shared import torch import gradio expected_torch_version = "2.1.2" expected_xformers_version = "0.0.23.post1" expected_gradio_version = "3.41.2" if version.parse(torch.__version__) < version.parse(expected_torch_version): print_error_explanation(f""" You are running torch {torch.__version__}. The program is tested to work with torch {expected_torch_version}. To reinstall the desired version, run with commandline flag --reinstall-torch. Beware that this will cause a lot of large files to be downloaded, as well as there are reports of issues with training tab on the latest version. Use --skip-version-check commandline argument to disable this check. """.strip()) if shared.xformers_available: import xformers if version.parse(xformers.__version__) < version.parse(expected_xformers_version): print_error_explanation(f""" You are running xformers {xformers.__version__}. The program is tested to work with xformers {expected_xformers_version}. To reinstall the desired version, run with commandline flag --reinstall-xformers. Use --skip-version-check commandline argument to disable this check. """.strip()) if gradio.__version__ != expected_gradio_version: print_error_explanation(f""" You are running gradio {gradio.__version__}. The program is designed to work with gradio {expected_gradio_version}. Using a different version of gradio is extremely likely to break the program. Reasons why you have the mismatched gradio version can be: - you use --skip-install flag. - you use webui.py to start the program instead of launch.py. - an extension installs the incompatible gradio version. Use --skip-version-check commandline argument to disable this check. """.strip())