Merge branch 'master' into fix-vram

function check_progressbar(id_part, id_progressbar, id_progressbar_span, id_interrupt, id_preview, id_gallery){

    var progressbar = gradioApp().getElementById(id_progressbar)

    var interrupt = gradioApp().getElementById(id_interrupt)

    if(opts.show_progress_in_title && progressbar && progressbar.offsetParent){

        if(progressbar.innerText){

            let newtitle = 'Stable Diffusion - ' + progressbar.innerText

            if(document.title != newtitle){

                document.title =  newtitle;          

            }

        }else{

            let newtitle = 'Stable Diffusion'

            if(document.title != newtitle){

                document.title =  newtitle;          

            }

        }

    }

	if(progressbar!= null && progressbar != global_progressbars[id_progressbar]){

	    global_progressbars[id_progressbar] = progressbar

stable_diffusion_commit_hash = os.environ.get('STABLE_DIFFUSION_COMMIT_HASH', "69ae4b35e0a0f6ee1af8bb9a5d0016ccb27e36dc")

taming_transformers_commit_hash = os.environ.get('TAMING_TRANSFORMERS_COMMIT_HASH', "24268930bf1dce879235a7fddd0b2355b84d7ea6")

k_diffusion_commit_hash = os.environ.get('K_DIFFUSION_COMMIT_HASH', "a7ec1974d4ccb394c2dca275f42cd97490618924")

k_diffusion_commit_hash = os.environ.get('K_DIFFUSION_COMMIT_HASH', "f4e99857772fc3a126ba886aadf795a332774878")

codeformer_commit_hash = os.environ.get('CODEFORMER_COMMIT_HASH', "c5b4593074ba6214284d6acd5f1719b6c5d739af")

blip_commit_hash = os.environ.get('BLIP_COMMIT_HASH', "48211a1594f1321b00f14c9f7a5b4813144b2fb9")

    # TODO clone into temporary dir and move if successful

    if os.path.exists(dir):

        if commithash is None:

            return

        current_hash = run(f'"{git}" -C {dir} rev-parse HEAD', None, f"Couldn't determine {name}'s hash: {commithash}").strip()

        if current_hash == commithash:

            return

        run(f'"{git}" -C {dir} fetch', f"Fetching updates for {name}...", f"Couldn't fetch {name}")

        run(f'"{git}" -C {dir} checkout {commithash}', f"Checking out commint for {name} with hash: {commithash}...", f"Couldn't checkout commit {commithash} for {name}")

        return

    run(f'"{git}" clone "{url}" "{dir}"', f"Cloning {name} into {dir}...", f"Couldn't clone {name}")

from skimage import exposure

import modules.sd_hijack

from modules import devices, prompt_parser, masking, lowvram

from modules import devices, prompt_parser, masking, sd_samplers, lowvram

from modules.sd_hijack import model_hijack

from modules.sd_samplers import samplers, samplers_for_img2img

from modules.shared import opts, cmd_opts, state

import modules.shared as shared

import modules.face_restoration

        self.width = p.width

        self.height = p.height

        self.sampler_index = p.sampler_index

        self.sampler = samplers[p.sampler_index].name

        self.sampler = sd_samplers.samplers[p.sampler_index].name

        self.cfg_scale = p.cfg_scale

        self.steps = p.steps

        self.batch_size = p.batch_size

    generation_params = {

        "Steps": p.steps,

        "Sampler": samplers[p.sampler_index].name,

        "Sampler": sd_samplers.samplers[p.sampler_index].name,

        "CFG scale": p.cfg_scale,

        "Seed": all_seeds[index],

        "Face restoration": (opts.face_restoration_model if p.restore_faces else None),

            #c = p.sd_model.get_learned_conditioning(prompts)

            with devices.autocast():

                uc = prompt_parser.get_learned_conditioning(shared.sd_model, len(prompts) * [p.negative_prompt], p.steps)

                c = prompt_parser.get_learned_conditioning(shared.sd_model, prompts, p.steps)

                c = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, prompts, p.steps)

            if len(model_hijack.comments) > 0:

                for comment in model_hijack.comments:

            self.firstphase_height_truncated = int(scale * self.height)

    def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength):

        self.sampler = samplers[self.sampler_index].constructor(self.sd_model)

        self.sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers, self.sampler_index, self.sd_model)

        if not self.enable_hr:

            x = create_random_tensors([opt_C, self.height // opt_f, self.width // opt_f], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

        shared.state.nextjob()

        self.sampler = samplers[self.sampler_index].constructor(self.sd_model)

        self.sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers, self.sampler_index, self.sd_model)

        noise = create_random_tensors(samples.shape[1:], seeds=seeds, subseeds=subseeds, subseed_strength=subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

        # GC now before running the next img2img to prevent running out of memory

        self.nmask = None

    def init(self, all_prompts, all_seeds, all_subseeds):

        self.sampler = samplers_for_img2img[self.sampler_index].constructor(self.sd_model)

        self.sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers_for_img2img, self.sampler_index, self.sd_model)

        crop_region = None

        if self.image_mask is not None:

import re

from collections import namedtuple

from typing import List

import lark

# a prompt like this: "fantasy landscape with a [mountain:lake:0.25] and [an oak:a christmas tree:0.75][ in foreground::0.6][ in background:0.25] [shoddy:masterful:0.5]"

ScheduledPromptConditioning = namedtuple("ScheduledPromptConditioning", ["end_at_step", "cond"])

ScheduledPromptBatch = namedtuple("ScheduledPromptBatch", ["shape", "schedules"])

def get_learned_conditioning(model, prompts, steps):

    """converts a list of prompts into a list of prompt schedules - each schedule is a list of ScheduledPromptConditioning, specifying the comdition (cond),

    and the sampling step at which this condition is to be replaced by the next one.

    Input:

    (model, ['a red crown', 'a [blue:green:5] jeweled crown'], 20)

    Output:

    [

        [

            ScheduledPromptConditioning(end_at_step=20, cond=tensor([[-0.3886,  0.0229, -0.0523,  ..., -0.4901, -0.3066,  0.0674], ..., [ 0.3317, -0.5102, -0.4066,  ...,  0.4119, -0.7647, -1.0160]], device='cuda:0'))

        ],

        [

            ScheduledPromptConditioning(end_at_step=5, cond=tensor([[-0.3886,  0.0229, -0.0522,  ..., -0.4901, -0.3067,  0.0673], ..., [-0.0192,  0.3867, -0.4644,  ...,  0.1135, -0.3696, -0.4625]], device='cuda:0')),

            ScheduledPromptConditioning(end_at_step=20, cond=tensor([[-0.3886,  0.0229, -0.0522,  ..., -0.4901, -0.3067,  0.0673], ..., [-0.7352, -0.4356, -0.7888,  ...,  0.6994, -0.4312, -1.2593]], device='cuda:0'))

        ]

    ]

    """

    res = []

    prompt_schedules = get_learned_conditioning_prompt_schedules(prompts, steps)

        cache[prompt] = cond_schedule

        res.append(cond_schedule)

    return ScheduledPromptBatch((len(prompts),) + res[0][0].cond.shape, res)

    return res

re_AND = re.compile(r"\bAND\b")

re_weight = re.compile(r"^(.*?)(?:\s*:\s*([-+]?(?:\d+\.?|\d*\.\d+)))?\s*$")

def get_multicond_prompt_list(prompts):

    res_indexes = []

    prompt_flat_list = []

    prompt_indexes = {}

    for prompt in prompts:

        subprompts = re_AND.split(prompt)

        indexes = []

        for subprompt in subprompts:

            match = re_weight.search(subprompt)

            text, weight = match.groups() if match is not None else (subprompt, 1.0)

            weight = float(weight) if weight is not None else 1.0

def reconstruct_cond_batch(c: ScheduledPromptBatch, current_step):

    param = c.schedules[0][0].cond

    res = torch.zeros(c.shape, device=param.device, dtype=param.dtype)

    for i, cond_schedule in enumerate(c.schedules):

            index = prompt_indexes.get(text, None)

            if index is None:

                index = len(prompt_flat_list)

                prompt_flat_list.append(text)

                prompt_indexes[text] = index

            indexes.append((index, weight))

        res_indexes.append(indexes)

    return res_indexes, prompt_flat_list, prompt_indexes

class ComposableScheduledPromptConditioning:

    def __init__(self, schedules, weight=1.0):

        self.schedules: List[ScheduledPromptConditioning] = schedules

        self.weight: float = weight

class MulticondLearnedConditioning:

    def __init__(self, shape, batch):

        self.shape: tuple = shape  # the shape field is needed to send this object to DDIM/PLMS

        self.batch: List[List[ComposableScheduledPromptConditioning]] = batch

def get_multicond_learned_conditioning(model, prompts, steps) -> MulticondLearnedConditioning:

    """same as get_learned_conditioning, but returns a list of ScheduledPromptConditioning along with the weight objects for each prompt.

    For each prompt, the list is obtained by splitting the prompt using the AND separator.

    https://energy-based-model.github.io/Compositional-Visual-Generation-with-Composable-Diffusion-Models/

    """

    res_indexes, prompt_flat_list, prompt_indexes = get_multicond_prompt_list(prompts)

    learned_conditioning = get_learned_conditioning(model, prompt_flat_list, steps)

    res = []

    for indexes in res_indexes:

        res.append([ComposableScheduledPromptConditioning(learned_conditioning[i], weight) for i, weight in indexes])

    return MulticondLearnedConditioning(shape=(len(prompts),), batch=res)

def reconstruct_cond_batch(c: List[List[ScheduledPromptConditioning]], current_step):

    param = c[0][0].cond

    res = torch.zeros((len(c),) + param.shape, device=param.device, dtype=param.dtype)

    for i, cond_schedule in enumerate(c):

        target_index = 0

        for current, (end_at, cond) in enumerate(cond_schedule):

            if current_step <= end_at:

    return res

def reconstruct_multicond_batch(c: MulticondLearnedConditioning, current_step):

    param = c.batch[0][0].schedules[0].cond

    tensors = []

    conds_list = []

    for batch_no, composable_prompts in enumerate(c.batch):

        conds_for_batch = []

        for cond_index, composable_prompt in enumerate(composable_prompts):

            target_index = 0

            for current, (end_at, cond) in enumerate(composable_prompt.schedules):

                if current_step <= end_at:

                    target_index = current

                    break

            conds_for_batch.append((len(tensors), composable_prompt.weight))

            tensors.append(composable_prompt.schedules[target_index].cond)

        conds_list.append(conds_for_batch)

    return conds_list, torch.stack(tensors).to(device=param.device, dtype=param.dtype)

re_attention = re.compile(r"""

\\\(|

\\\)|

import modules.shared as shared

SamplerData = namedtuple('SamplerData', ['name', 'constructor', 'aliases'])

SamplerData = namedtuple('SamplerData', ['name', 'constructor', 'aliases', 'options'])

samplers_k_diffusion = [

    ('Euler a', 'sample_euler_ancestral', ['k_euler_a']),

    ('Euler', 'sample_euler', ['k_euler']),

    ('LMS', 'sample_lms', ['k_lms']),

    ('Heun', 'sample_heun', ['k_heun']),

    ('DPM2', 'sample_dpm_2', ['k_dpm_2']),

    ('DPM2 a', 'sample_dpm_2_ancestral', ['k_dpm_2_a']),

    ('DPM fast', 'sample_dpm_fast', ['k_dpm_fast']),

    ('DPM adaptive', 'sample_dpm_adaptive', ['k_dpm_ad']),

    ('Euler a', 'sample_euler_ancestral', ['k_euler_a'], {}),

    ('Euler', 'sample_euler', ['k_euler'], {}),

    ('LMS', 'sample_lms', ['k_lms'], {}),

    ('Heun', 'sample_heun', ['k_heun'], {}),

    ('DPM2', 'sample_dpm_2', ['k_dpm_2'], {}),

    ('DPM2 a', 'sample_dpm_2_ancestral', ['k_dpm_2_a'], {}),

    ('DPM fast', 'sample_dpm_fast', ['k_dpm_fast'], {}),

    ('DPM adaptive', 'sample_dpm_adaptive', ['k_dpm_ad'], {}),

    ('LMS Karras', 'sample_lms', ['k_lms_ka'], {'scheduler': 'karras'}),

    ('DPM2 Karras', 'sample_dpm_2', ['k_dpm_2_ka'], {'scheduler': 'karras'}),

    ('DPM2 a Karras', 'sample_dpm_2_ancestral', ['k_dpm_2_a_ka'], {'scheduler': 'karras'}),

]

samplers_data_k_diffusion = [

    SamplerData(label, lambda model, funcname=funcname: KDiffusionSampler(funcname, model), aliases)

    for label, funcname, aliases in samplers_k_diffusion

    SamplerData(label, lambda model, funcname=funcname: KDiffusionSampler(funcname, model), aliases, options)

    for label, funcname, aliases, options in samplers_k_diffusion

    if hasattr(k_diffusion.sampling, funcname)

]

samplers = [

all_samplers = [

    *samplers_data_k_diffusion,

    SamplerData('DDIM', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.ddim.DDIMSampler, model), []),

    SamplerData('PLMS', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.plms.PLMSSampler, model), []),

    SamplerData('DDIM', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.ddim.DDIMSampler, model), [], {}),

    SamplerData('PLMS', lambda model: VanillaStableDiffusionSampler(ldm.models.diffusion.plms.PLMSSampler, model), [], {}),

]

samplers_for_img2img = [x for x in samplers if x.name not in ['PLMS', 'DPM fast', 'DPM adaptive']]

samplers = []

samplers_for_img2img = []

def create_sampler_with_index(list_of_configs, index, model):

    config = list_of_configs[index]

    sampler = config.constructor(model)

    sampler.config = config

    return sampler

def set_samplers():

    global samplers, samplers_for_img2img

    hidden = set(opts.hide_samplers)

    hidden_img2img = set(opts.hide_samplers + ['PLMS', 'DPM fast', 'DPM adaptive'])

    samplers = [x for x in all_samplers if x.name not in hidden]

    samplers_for_img2img = [x for x in all_samplers if x.name not in hidden_img2img]

set_samplers()

sampler_extra_params = {

    'sample_euler': ['s_churn', 's_tmin', 's_tmax', 's_noise'],

        self.step = 0

        self.eta = None

        self.default_eta = 0.0

        self.config = None

    def number_of_needed_noises(self, p):

        return 0

    def p_sample_ddim_hook(self, x_dec, cond, ts, unconditional_conditioning, *args, **kwargs):

        cond = prompt_parser.reconstruct_cond_batch(cond, self.step)

        conds_list, tensor = prompt_parser.reconstruct_multicond_batch(cond, self.step)

        unconditional_conditioning = prompt_parser.reconstruct_cond_batch(unconditional_conditioning, self.step)

        assert all([len(conds) == 1 for conds in conds_list]), 'composition via AND is not supported for DDIM/PLMS samplers'

        cond = tensor

        if self.mask is not None:

            img_orig = self.sampler.model.q_sample(self.init_latent, ts)

            x_dec = img_orig * self.mask + self.nmask * x_dec

        self.step = 0

    def forward(self, x, sigma, uncond, cond, cond_scale):

        cond = prompt_parser.reconstruct_cond_batch(cond, self.step)

        conds_list, tensor = prompt_parser.reconstruct_multicond_batch(cond, self.step)

        uncond = prompt_parser.reconstruct_cond_batch(uncond, self.step)

        batch_size = len(conds_list)

        repeats = [len(conds_list[i]) for i in range(batch_size)]

        x_in = torch.cat([torch.stack([x[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [x])

        sigma_in = torch.cat([torch.stack([sigma[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [sigma])

        cond_in = torch.cat([tensor, uncond])

        if shared.batch_cond_uncond:

            x_in = torch.cat([x] * 2)

            sigma_in = torch.cat([sigma] * 2)

            cond_in = torch.cat([uncond, cond])

            uncond, cond = self.inner_model(x_in, sigma_in, cond=cond_in).chunk(2)

            denoised = uncond + (cond - uncond) * cond_scale

            x_out = self.inner_model(x_in, sigma_in, cond=cond_in)

        else:

            uncond = self.inner_model(x, sigma, cond=uncond)

            cond = self.inner_model(x, sigma, cond=cond)

            denoised = uncond + (cond - uncond) * cond_scale

            x_out = torch.zeros_like(x_in)

            for batch_offset in range(0, x_out.shape[0], batch_size):

                a = batch_offset

                b = a + batch_size

                x_out[a:b] = self.inner_model(x_in[a:b], sigma_in[a:b], cond=cond_in[a:b])

        denoised_uncond = x_out[-batch_size:]

        denoised = torch.clone(denoised_uncond)

        for i, conds in enumerate(conds_list):

            for cond_index, weight in conds:

                denoised[i] += (x_out[cond_index] - denoised_uncond[i]) * (weight * cond_scale)

        if self.mask is not None:

            denoised = self.init_latent * self.mask + self.nmask * denoised

        self.stop_at = None

        self.eta = None

        self.default_eta = 1.0

        self.config = None

    def callback_state(self, d):

        store_latent(d["denoised"])

        if p.sampler_noise_scheduler_override:

            sigmas = p.sampler_noise_scheduler_override(steps)

        elif self.config is not None and self.config.options.get('scheduler', None) == 'karras':

            sigmas = k_diffusion.sampling.get_sigmas_karras(n=steps, sigma_min=0.1, sigma_max=10, device=shared.device)

        else:

            sigmas = self.model_wrap.get_sigmas(steps)

        x = x * sigmas[0]

        extra_params_kwargs = self.initialize(p)