Merge branch 'dev' into multiple_loaded_models

                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').style(full_width=True, size="lg")

                generate_random_prompt = gr.Button('Generate', size="lg", scale=1)

        self.edit_notes = gr.TextArea(label='Notes', lines=4)

    train_hypernetwork: 'OPTION',

    txt2img_styles: 'OPTION',

    img2img_styles: 'OPTION',

    setting_random_artist_categories: 'SPAN',

    setting_face_restoration_model: 'SPAN',

    setting_realesrgan_enabled_models: 'SPAN',

    extras_upscaler_1: 'SPAN',

    extras_upscaler_2: 'SPAN',

    setting_random_artist_categories: 'OPTION',

    setting_face_restoration_model: 'OPTION',

    setting_realesrgan_enabled_models: 'OPTION',

    extras_upscaler_1: 'OPTION',

    extras_upscaler_2: 'OPTION',

};

var re_num = /^[.\d]+$/;

parser.add_argument('--add-stop-route', action='store_true', help='add /_stop route to stop server')

parser.add_argument('--api-server-stop', action='store_true', help='enable server stop/restart/kill via api')

parser.add_argument('--timeout-keep-alive', type=int, default=30, help='set timeout_keep_alive for uvicorn')

parser.add_argument("--disable-all-extensions", action='store_true', help="prevent all extensions from running regardless of any other settings", default=False)

parser.add_argument("--disable-extra-extensions", action='store_true', help=" prevent all extensions except built-in from running regardless of any other settings", default=False)

from functools import lru_cache

import torch

from modules import errors

from modules import errors, rng_philox

if sys.platform == "darwin":

    from modules import mac_specific

        torch.backends.cudnn.allow_tf32 = True

errors.run(enable_tf32, "Enabling TF32")

cpu = torch.device("cpu")

device = device_interrogate = device_gfpgan = device_esrgan = device_codeformer = None

dtype = torch.float16

dtype_vae = torch.float16

dtype_unet = torch.float16

cpu: torch.device = torch.device("cpu")

device: torch.device = None

device_interrogate: torch.device = None

device_gfpgan: torch.device = None

device_esrgan: torch.device = None

device_codeformer: torch.device = None

dtype: torch.dtype = torch.float16

dtype_vae: torch.dtype = torch.float16

dtype_unet: torch.dtype = torch.float16

unet_needs_upcast = False

    return input.float() if unet_needs_upcast else input

nv_rng = None

def randn(seed, shape):

    """Generate a tensor with random numbers from a normal distribution using seed.

    Uses the seed parameter to set the global torch seed; to generate more with that seed, use randn_like/randn_without_seed."""

    from modules.shared import opts

    torch.manual_seed(seed)

    manual_seed(seed)

    if opts.randn_source == "NV":

        return torch.asarray(nv_rng.randn(shape), device=device)

    if opts.randn_source == "CPU" or device.type == 'mps':

        return torch.randn(shape, device=cpu).to(device)

    return torch.randn(shape, device=device)

def randn_local(seed, shape):

    """Generate a tensor with random numbers from a normal distribution using seed.

    Does not change the global random number generator. You can only generate the seed's first tensor using this function."""

    from modules.shared import opts

    if opts.randn_source == "NV":

        rng = rng_philox.Generator(seed)

        return torch.asarray(rng.randn(shape), device=device)

    local_device = cpu if opts.randn_source == "CPU" or device.type == 'mps' else device

    local_generator = torch.Generator(local_device).manual_seed(int(seed))

    return torch.randn(shape, device=local_device, generator=local_generator).to(device)

def randn_like(x):

    """Generate a tensor with random numbers from a normal distribution using the previously initialized genrator.

    Use either randn() or manual_seed() to initialize the generator."""

    from modules.shared import opts

    if opts.randn_source == "NV":

        return torch.asarray(nv_rng.randn(x.shape), device=x.device, dtype=x.dtype)

    if opts.randn_source == "CPU" or x.device.type == 'mps':

        return torch.randn_like(x, device=cpu).to(x.device)

    return torch.randn_like(x)

def randn_without_seed(shape):

    """Generate a tensor with random numbers from a normal distribution using the previously initialized genrator.

    Use either randn() or manual_seed() to initialize the generator."""

    from modules.shared import opts

    if opts.randn_source == "NV":

        return torch.asarray(nv_rng.randn(shape), device=device)

    if opts.randn_source == "CPU" or device.type == 'mps':

        return torch.randn(shape, device=cpu).to(device)

    return torch.randn(shape, device=device)

def manual_seed(seed):

    """Set up a global random number generator using the specified seed."""

    from modules.shared import opts

    if opts.randn_source == "NV":

        global nv_rng

        nv_rng = rng_philox.Generator(seed)

        return

    torch.manual_seed(seed)

def autocast(disable=False):

    from modules import shared

        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.0.0"

    expected_xformers_version = "0.0.20"

    expected_gradio_version = "3.39.0"

    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())