Merge branch 'master' of github.com:AUTOMATIC1111/stable-diffusion-webui into gamepad

    "Interrogate": "Reconstruct prompt from existing image and put it into the prompt field.",

    "Images filename pattern": "Use following tags to define how filenames for images are chosen: [steps], [cfg], [prompt], [prompt_no_styles], [prompt_spaces], [width], [height], [styles], [sampler], [seed], [model_hash], [model_name], [prompt_words], [date], [datetime], [datetime<Format>], [datetime<Format><Time Zone>], [job_timestamp]; leave empty for default.",

    "Directory name pattern": "Use following tags to define how subdirectories for images and grids are chosen: [steps], [cfg], [prompt], [prompt_no_styles], [prompt_spaces], [width], [height], [styles], [sampler], [seed], [model_hash], [model_name], [prompt_words], [date], [datetime], [datetime<Format>], [datetime<Format><Time Zone>], [job_timestamp]; leave empty for default.",

    "Images filename pattern": "Use following tags to define how filenames for images are chosen: [steps], [cfg], [prompt_hash], [prompt], [prompt_no_styles], [prompt_spaces], [width], [height], [styles], [sampler], [seed], [model_hash], [model_name], [prompt_words], [date], [datetime], [datetime<Format>], [datetime<Format><Time Zone>], [job_timestamp]; leave empty for default.",

    "Directory name pattern": "Use following tags to define how subdirectories for images and grids are chosen: [steps], [cfg],[prompt_hash], [prompt], [prompt_no_styles], [prompt_spaces], [width], [height], [styles], [sampler], [seed], [model_hash], [model_name], [prompt_words], [date], [datetime], [datetime<Format>], [datetime<Format><Time Zone>], [job_timestamp]; leave empty for default.",

    "Max prompt words": "Set the maximum number of words to be used in the [prompt_words] option; ATTENTION: If the words are too long, they may exceed the maximum length of the file path that the system can handle",

    "Loopback": "Process an image, use it as an input, repeat.",

import sys, os, shlex

import sys

import contextlib

import torch

from modules import errors

from modules.sd_hijack_utils import CondFunc

from packaging import version

if sys.platform == "darwin":

    from modules import mac_specific

# has_mps is only available in nightly pytorch (for now) and macOS 12.3+.

# check `getattr` and try it for compatibility

def has_mps() -> bool:

    if not getattr(torch, 'has_mps', False):

        return False

    try:

        torch.zeros(1).to(torch.device("mps"))

        return True

    except Exception:

    if sys.platform != "darwin":

        return False

    else:

        return mac_specific.has_mps

def extract_device_id(args, name):

    for x in range(len(args)):

    message += " Use --disable-nan-check commandline argument to disable this check."

    raise NansException(message)

# MPS workaround for https://github.com/pytorch/pytorch/issues/89784

def cumsum_fix(input, cumsum_func, *args, **kwargs):

    if input.device.type == 'mps':

        output_dtype = kwargs.get('dtype', input.dtype)

        if output_dtype == torch.int64:

            return cumsum_func(input.cpu(), *args, **kwargs).to(input.device)

        elif cumsum_needs_bool_fix and output_dtype == torch.bool or cumsum_needs_int_fix and (output_dtype == torch.int8 or output_dtype == torch.int16):

            return cumsum_func(input.to(torch.int32), *args, **kwargs).to(torch.int64)

    return cumsum_func(input, *args, **kwargs)

if has_mps():

    if version.parse(torch.__version__) < version.parse("1.13"):

        # PyTorch 1.13 doesn't need these fixes but unfortunately is slower and has regressions that prevent training from working

        # MPS workaround for https://github.com/pytorch/pytorch/issues/79383

        CondFunc('torch.Tensor.to', lambda orig_func, self, *args, **kwargs: orig_func(self.contiguous(), *args, **kwargs),

                                                          lambda _, self, *args, **kwargs: self.device.type != 'mps' and (args and isinstance(args[0], torch.device) and args[0].type == 'mps' or isinstance(kwargs.get('device'), torch.device) and kwargs['device'].type == 'mps'))

        # MPS workaround for https://github.com/pytorch/pytorch/issues/80800 

        CondFunc('torch.nn.functional.layer_norm', lambda orig_func, *args, **kwargs: orig_func(*([args[0].contiguous()] + list(args[1:])), **kwargs),

                                                                                        lambda _, *args, **kwargs: args and isinstance(args[0], torch.Tensor) and args[0].device.type == 'mps')

        # MPS workaround for https://github.com/pytorch/pytorch/issues/90532

        CondFunc('torch.Tensor.numpy', lambda orig_func, self, *args, **kwargs: orig_func(self.detach(), *args, **kwargs), lambda _, self, *args, **kwargs: self.requires_grad)

    elif version.parse(torch.__version__) > version.parse("1.13.1"):

        cumsum_needs_int_fix = not torch.Tensor([1,2]).to(torch.device("mps")).equal(torch.ShortTensor([1,1]).to(torch.device("mps")).cumsum(0))

        cumsum_needs_bool_fix = not torch.BoolTensor([True,True]).to(device=torch.device("mps"), dtype=torch.int64).equal(torch.BoolTensor([True,False]).to(torch.device("mps")).cumsum(0))

        cumsum_fix_func = lambda orig_func, input, *args, **kwargs: cumsum_fix(input, orig_func, *args, **kwargs)

        CondFunc('torch.cumsum', cumsum_fix_func, None)

        CondFunc('torch.Tensor.cumsum', cumsum_fix_func, None)

        CondFunc('torch.narrow', lambda orig_func, *args, **kwargs: orig_func(*args, **kwargs).clone(), None)

import filelock

from modules import shared

from modules.paths import data_path

    if sha256_value is not None:

        return sha256_value

    if shared.cmd_opts.no_hashing:

        return None

    print(f"Calculating sha256 for {filename}: ", end='')

    sha256_value = calculate_sha256(filename)

    print(f"{sha256_value}")

    def shorthash(self):

        sha256 = hashes.sha256(self.filename, f'hypernet/{self.name}')

        return sha256[0:10]

        return sha256[0:10] if sha256 else None

def list_hypernetworks(path):

from fonts.ttf import Roboto

import string

import json

import hashlib

from modules import sd_samplers, shared, script_callbacks

from modules.shared import opts, cmd_opts

        self.size = None

def draw_grid_annotations(im, width, height, hor_texts, ver_texts):

def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0):

    def wrap(drawing, text, font, line_length):

        lines = ['']

        for word in text.split():

            line.allowed_width = allowed_width

    hor_text_heights = [sum([line.size[1] + line_spacing for line in lines]) - line_spacing for lines in hor_texts]

    ver_text_heights = [sum([line.size[1] + line_spacing for line in lines]) - line_spacing * len(lines) for lines in

                        ver_texts]

    ver_text_heights = [sum([line.size[1] + line_spacing for line in lines]) - line_spacing * len(lines) for lines in ver_texts]

    pad_top = 0 if sum(hor_text_heights) == 0 else max(hor_text_heights) + line_spacing * 2

    result = Image.new("RGB", (im.width + pad_left, im.height + pad_top), "white")

    result.paste(im, (pad_left, pad_top))

    result = Image.new("RGB", (im.width + pad_left + margin * (cols-1), im.height + pad_top + margin * (rows-1)), "white")

    for row in range(rows):

        for col in range(cols):

            cell = im.crop((width * col, height * row, width * (col+1), height * (row+1)))

            result.paste(cell, (pad_left + (width + margin) * col, pad_top + (height + margin) * row))

    d = ImageDraw.Draw(result)

    for col in range(cols):

        x = pad_left + width * col + width / 2

        x = pad_left + (width + margin) * col + width / 2

        y = pad_top / 2 - hor_text_heights[col] / 2

        draw_texts(d, x, y, hor_texts[col], fnt, fontsize)

    for row in range(rows):

        x = pad_left / 2

        y = pad_top + height * row + height / 2 - ver_text_heights[row] / 2

        y = pad_top + (height + margin) * row + height / 2 - ver_text_heights[row] / 2

        draw_texts(d, x, y, ver_texts[row], fnt, fontsize)

    return result

def draw_prompt_matrix(im, width, height, all_prompts):

def draw_prompt_matrix(im, width, height, all_prompts, margin=0):

    prompts = all_prompts[1:]

    boundary = math.ceil(len(prompts) / 2)

    hor_texts = [[GridAnnotation(x, is_active=pos & (1 << i) != 0) for i, x in enumerate(prompts_horiz)] for pos in range(1 << len(prompts_horiz))]

    ver_texts = [[GridAnnotation(x, is_active=pos & (1 << i) != 0) for i, x in enumerate(prompts_vert)] for pos in range(1 << len(prompts_vert))]

    return draw_grid_annotations(im, width, height, hor_texts, ver_texts)

    return draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin)

def resize_image(resize_mode, im, width, height, upscaler_name=None):

        'date': lambda self: datetime.datetime.now().strftime('%Y-%m-%d'),

        'datetime': lambda self, *args: self.datetime(*args),  # accepts formats: [datetime], [datetime<Format>], [datetime<Format><Time Zone>]

        'job_timestamp': lambda self: getattr(self.p, "job_timestamp", shared.state.job_timestamp),

        'prompt_hash': lambda self: hashlib.sha256(self.prompt.encode()).hexdigest()[0:8],

        'prompt': lambda self: sanitize_filename_part(self.prompt),

        'prompt_no_styles': lambda self: self.prompt_no_style(),

        'prompt_spaces': lambda self: sanitize_filename_part(self.prompt, replace_spaces=False),