Delete modules

modules/images.py

@@ -1,778 +0,0 @@
-from __future__ import annotations
-
-import datetime
-
-import pytz
-import io
-import math
-import os
-from collections import namedtuple
-import re
-
-import numpy as np
-import piexif
-import piexif.helper
-from PIL import Image, ImageFont, ImageDraw, ImageColor, PngImagePlugin
-import string
-import json
-import hashlib
-
-from modules import sd_samplers, shared, script_callbacks, errors
-from modules.paths_internal import roboto_ttf_file
-from modules.shared import opts
-
-LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)
-
-
-def get_font(fontsize: int):
-    try:
-        return ImageFont.truetype(opts.font or roboto_ttf_file, fontsize)
-    except Exception:
-        return ImageFont.truetype(roboto_ttf_file, fontsize)
-
-
-def image_grid(imgs, batch_size=1, rows=None):
-    if rows is None:
-        if opts.n_rows > 0:
-            rows = opts.n_rows
-        elif opts.n_rows == 0:
-            rows = batch_size
-        elif opts.grid_prevent_empty_spots:
-            rows = math.floor(math.sqrt(len(imgs)))
-            while len(imgs) % rows != 0:
-                rows -= 1
-        else:
-            rows = math.sqrt(len(imgs))
-            rows = round(rows)
-    if rows > len(imgs):
-        rows = len(imgs)
-
-    cols = math.ceil(len(imgs) / rows)
-
-    params = script_callbacks.ImageGridLoopParams(imgs, cols, rows)
-    script_callbacks.image_grid_callback(params)
-
-    w, h = imgs[0].size
-    grid = Image.new('RGB', size=(params.cols * w, params.rows * h), color='black')
-
-    for i, img in enumerate(params.imgs):
-        grid.paste(img, box=(i % params.cols * w, i // params.cols * h))
-
-    return grid
-
-
-Grid = namedtuple("Grid", ["tiles", "tile_w", "tile_h", "image_w", "image_h", "overlap"])
-
-
-def split_grid(image, tile_w=512, tile_h=512, overlap=64):
-    w = image.width
-    h = image.height
-
-    non_overlap_width = tile_w - overlap
-    non_overlap_height = tile_h - overlap
-
-    cols = math.ceil((w - overlap) / non_overlap_width)
-    rows = math.ceil((h - overlap) / non_overlap_height)
-
-    dx = (w - tile_w) / (cols - 1) if cols > 1 else 0
-    dy = (h - tile_h) / (rows - 1) if rows > 1 else 0
-
-    grid = Grid([], tile_w, tile_h, w, h, overlap)
-    for row in range(rows):
-        row_images = []
-
-        y = int(row * dy)
-
-        if y + tile_h >= h:
-            y = h - tile_h
-
-        for col in range(cols):
-            x = int(col * dx)
-
-            if x + tile_w >= w:
-                x = w - tile_w
-
-            tile = image.crop((x, y, x + tile_w, y + tile_h))
-
-            row_images.append([x, tile_w, tile])
-
-        grid.tiles.append([y, tile_h, row_images])
-
-    return grid
-
-
-def combine_grid(grid):
-    def make_mask_image(r):
-        r = r * 255 / grid.overlap
-        r = r.astype(np.uint8)
-        return Image.fromarray(r, 'L')
-
-    mask_w = make_mask_image(np.arange(grid.overlap, dtype=np.float32).reshape((1, grid.overlap)).repeat(grid.tile_h, axis=0))
-    mask_h = make_mask_image(np.arange(grid.overlap, dtype=np.float32).reshape((grid.overlap, 1)).repeat(grid.image_w, axis=1))
-
-    combined_image = Image.new("RGB", (grid.image_w, grid.image_h))
-    for y, h, row in grid.tiles:
-        combined_row = Image.new("RGB", (grid.image_w, h))
-        for x, w, tile in row:
-            if x == 0:
-                combined_row.paste(tile, (0, 0))
-                continue
-
-            combined_row.paste(tile.crop((0, 0, grid.overlap, h)), (x, 0), mask=mask_w)
-            combined_row.paste(tile.crop((grid.overlap, 0, w, h)), (x + grid.overlap, 0))
-
-        if y == 0:
-            combined_image.paste(combined_row, (0, 0))
-            continue
-
-        combined_image.paste(combined_row.crop((0, 0, combined_row.width, grid.overlap)), (0, y), mask=mask_h)
-        combined_image.paste(combined_row.crop((0, grid.overlap, combined_row.width, h)), (0, y + grid.overlap))
-
-    return combined_image
-
-
-class GridAnnotation:
-    def __init__(self, text='', is_active=True):
-        self.text = text
-        self.is_active = is_active
-        self.size = None
-
-
-def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0):
-
-    color_active = ImageColor.getcolor(opts.grid_text_active_color, 'RGB')
-    color_inactive = ImageColor.getcolor(opts.grid_text_inactive_color, 'RGB')
-    color_background = ImageColor.getcolor(opts.grid_background_color, 'RGB')
-
-    def wrap(drawing, text, font, line_length):
-        lines = ['']
-        for word in text.split():
-            line = f'{lines[-1]} {word}'.strip()
-            if drawing.textlength(line, font=font) <= line_length:
-                lines[-1] = line
-            else:
-                lines.append(word)
-        return lines
-
-    def draw_texts(drawing, draw_x, draw_y, lines, initial_fnt, initial_fontsize):
-        for line in lines:
-            fnt = initial_fnt
-            fontsize = initial_fontsize
-            while drawing.multiline_textsize(line.text, font=fnt)[0] > line.allowed_width and fontsize > 0:
-                fontsize -= 1
-                fnt = get_font(fontsize)
-            drawing.multiline_text((draw_x, draw_y + line.size[1] / 2), line.text, font=fnt, fill=color_active if line.is_active else color_inactive, anchor="mm", align="center")
-
-            if not line.is_active:
-                drawing.line((draw_x - line.size[0] // 2, draw_y + line.size[1] // 2, draw_x + line.size[0] // 2, draw_y + line.size[1] // 2), fill=color_inactive, width=4)
-
-            draw_y += line.size[1] + line_spacing
-
-    fontsize = (width + height) // 25
-    line_spacing = fontsize // 2
-
-    fnt = get_font(fontsize)
-
-    pad_left = 0 if sum([sum([len(line.text) for line in lines]) for lines in ver_texts]) == 0 else width * 3 // 4
-
-    cols = im.width // width
-    rows = im.height // height
-
-    assert cols == len(hor_texts), f'bad number of horizontal texts: {len(hor_texts)}; must be {cols}'
-    assert rows == len(ver_texts), f'bad number of vertical texts: {len(ver_texts)}; must be {rows}'
-
-    calc_img = Image.new("RGB", (1, 1), color_background)
-    calc_d = ImageDraw.Draw(calc_img)
-
-    for texts, allowed_width in zip(hor_texts + ver_texts, [width] * len(hor_texts) + [pad_left] * len(ver_texts)):
-        items = [] + texts
-        texts.clear()
-
-        for line in items:
-            wrapped = wrap(calc_d, line.text, fnt, allowed_width)
-            texts += [GridAnnotation(x, line.is_active) for x in wrapped]
-
-        for line in texts:
-            bbox = calc_d.multiline_textbbox((0, 0), line.text, font=fnt)
-            line.size = (bbox[2] - bbox[0], bbox[3] - bbox[1])
-            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]
-
-    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 + margin * (cols-1), im.height + pad_top + margin * (rows-1)), color_background)
-
-    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 + 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 + 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, margin=0):
-    prompts = all_prompts[1:]
-    boundary = math.ceil(len(prompts) / 2)
-
-    prompts_horiz = prompts[:boundary]
-    prompts_vert = prompts[boundary:]
-
-    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, margin)
-
-
-def resize_image(resize_mode, im, width, height, upscaler_name=None):
-    """
-    Resizes an image with the specified resize_mode, width, and height.
-
-    Args:
-        resize_mode: The mode to use when resizing the image.
-            0: Resize the image to the specified width and height.
-            1: Resize the image to fill the specified width and height, maintaining the aspect ratio, and then center the image within the dimensions, cropping the excess.
-            2: Resize the image to fit within the specified width and height, maintaining the aspect ratio, and then center the image within the dimensions, filling empty with data from image.
-        im: The image to resize.
-        width: The width to resize the image to.
-        height: The height to resize the image to.
-        upscaler_name: The name of the upscaler to use. If not provided, defaults to opts.upscaler_for_img2img.
-    """
-
-    upscaler_name = upscaler_name or opts.upscaler_for_img2img
-
-    def resize(im, w, h):
-        if upscaler_name is None or upscaler_name == "None" or im.mode == 'L':
-            return im.resize((w, h), resample=LANCZOS)
-
-        scale = max(w / im.width, h / im.height)
-
-        if scale > 1.0:
-            upscalers = [x for x in shared.sd_upscalers if x.name == upscaler_name]
-            if len(upscalers) == 0:
-                upscaler = shared.sd_upscalers[0]
-                print(f"could not find upscaler named {upscaler_name or '<empty string>'}, using {upscaler.name} as a fallback")
-            else:
-                upscaler = upscalers[0]
-
-            im = upscaler.scaler.upscale(im, scale, upscaler.data_path)
-
-        if im.width != w or im.height != h:
-            im = im.resize((w, h), resample=LANCZOS)
-
-        return im
-
-    if resize_mode == 0:
-        res = resize(im, width, height)
-
-    elif resize_mode == 1:
-        ratio = width / height
-        src_ratio = im.width / im.height
-
-        src_w = width if ratio > src_ratio else im.width * height // im.height
-        src_h = height if ratio <= src_ratio else im.height * width // im.width
-
-        resized = resize(im, src_w, src_h)
-        res = Image.new("RGB", (width, height))
-        res.paste(resized, box=(width // 2 - src_w // 2, height // 2 - src_h // 2))
-
-    else:
-        ratio = width / height
-        src_ratio = im.width / im.height
-
-        src_w = width if ratio < src_ratio else im.width * height // im.height
-        src_h = height if ratio >= src_ratio else im.height * width // im.width
-
-        resized = resize(im, src_w, src_h)
-        res = Image.new("RGB", (width, height))
-        res.paste(resized, box=(width // 2 - src_w // 2, height // 2 - src_h // 2))
-
-        if ratio < src_ratio:
-            fill_height = height // 2 - src_h // 2
-            if fill_height > 0:
-                res.paste(resized.resize((width, fill_height), box=(0, 0, width, 0)), box=(0, 0))
-                res.paste(resized.resize((width, fill_height), box=(0, resized.height, width, resized.height)), box=(0, fill_height + src_h))
-        elif ratio > src_ratio:
-            fill_width = width // 2 - src_w // 2
-            if fill_width > 0:
-                res.paste(resized.resize((fill_width, height), box=(0, 0, 0, height)), box=(0, 0))
-                res.paste(resized.resize((fill_width, height), box=(resized.width, 0, resized.width, height)), box=(fill_width + src_w, 0))
-
-    return res
-
-
-invalid_filename_chars = '<>:"/\\|?*\n\r\t'
-invalid_filename_prefix = ' '
-invalid_filename_postfix = ' .'
-re_nonletters = re.compile(r'[\s' + string.punctuation + ']+')
-re_pattern = re.compile(r"(.*?)(?:\[([^\[\]]+)\]|$)")
-re_pattern_arg = re.compile(r"(.*)<([^>]*)>$")
-max_filename_part_length = 128
-NOTHING_AND_SKIP_PREVIOUS_TEXT = object()
-
-
-def sanitize_filename_part(text, replace_spaces=True):
-    if text is None:
-        return None
-
-    if replace_spaces:
-        text = text.replace(' ', '_')
-
-    text = text.translate({ord(x): '_' for x in invalid_filename_chars})
-    text = text.lstrip(invalid_filename_prefix)[:max_filename_part_length]
-    text = text.rstrip(invalid_filename_postfix)
-    return text
-
-
-class FilenameGenerator:
-    replacements = {
-        'seed': lambda self: self.seed if self.seed is not None else '',
-        'seed_first': lambda self: self.seed if self.p.batch_size == 1 else self.p.all_seeds[0],
-        'seed_last': lambda self: NOTHING_AND_SKIP_PREVIOUS_TEXT if self.p.batch_size == 1 else self.p.all_seeds[-1],
-        'steps': lambda self:  self.p and self.p.steps,
-        'cfg': lambda self: self.p and self.p.cfg_scale,
-        'width': lambda self: self.image.width,
-        'height': lambda self: self.image.height,
-        'styles': lambda self: self.p and sanitize_filename_part(", ".join([style for style in self.p.styles if not style == "None"]) or "None", replace_spaces=False),
-        'sampler': lambda self: self.p and sanitize_filename_part(self.p.sampler_name, replace_spaces=False),
-        'model_hash': lambda self: getattr(self.p, "sd_model_hash", shared.sd_model.sd_model_hash),
-        'model_name': lambda self: sanitize_filename_part(shared.sd_model.sd_checkpoint_info.name_for_extra, replace_spaces=False),
-        '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, *args: self.string_hash(self.prompt, *args),
-        'negative_prompt_hash': lambda self, *args: self.string_hash(self.p.negative_prompt, *args),
-        'full_prompt_hash': lambda self, *args: self.string_hash(f"{self.p.prompt} {self.p.negative_prompt}", *args),  # a space in between to create a unique string
-        '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),
-        'prompt_words': lambda self: self.prompt_words(),
-        'batch_number': lambda self: NOTHING_AND_SKIP_PREVIOUS_TEXT if self.p.batch_size == 1 or self.zip else self.p.batch_index + 1,
-        'batch_size': lambda self: self.p.batch_size,
-        'generation_number': lambda self: NOTHING_AND_SKIP_PREVIOUS_TEXT if (self.p.n_iter == 1 and self.p.batch_size == 1) or self.zip else self.p.iteration * self.p.batch_size + self.p.batch_index + 1,
-        'hasprompt': lambda self, *args: self.hasprompt(*args),  # accepts formats:[hasprompt<prompt1|default><prompt2>..]
-        'clip_skip': lambda self: opts.data["CLIP_stop_at_last_layers"],
-        'denoising': lambda self: self.p.denoising_strength if self.p and self.p.denoising_strength else NOTHING_AND_SKIP_PREVIOUS_TEXT,
-        'user': lambda self: self.p.user,
-        'vae_filename': lambda self: self.get_vae_filename(),
-        'none': lambda self: '',  # Overrides the default, so you can get just the sequence number
-        'image_hash': lambda self, *args: self.image_hash(*args)  # accepts formats: [image_hash<length>] default full hash
-    }
-    default_time_format = '%Y%m%d%H%M%S'
-
-    def __init__(self, p, seed, prompt, image, zip=False):
-        self.p = p
-        self.seed = seed
-        self.prompt = prompt
-        self.image = image
-        self.zip = zip
-
-    def get_vae_filename(self):
-        """Get the name of the VAE file."""
-
-        import modules.sd_vae as sd_vae
-
-        if sd_vae.loaded_vae_file is None:
-            return "NoneType"
-
-        file_name = os.path.basename(sd_vae.loaded_vae_file)
-        split_file_name = file_name.split('.')
-        if len(split_file_name) > 1 and split_file_name[0] == '':
-            return split_file_name[1]  # if the first character of the filename is "." then [1] is obtained.
-        else:
-            return split_file_name[0]
-
-
-    def hasprompt(self, *args):
-        lower = self.prompt.lower()
-        if self.p is None or self.prompt is None:
-            return None
-        outres = ""
-        for arg in args:
-            if arg != "":
-                division = arg.split("|")
-                expected = division[0].lower()
-                default = division[1] if len(division) > 1 else ""
-                if lower.find(expected) >= 0:
-                    outres = f'{outres}{expected}'
-                else:
-                    outres = outres if default == "" else f'{outres}{default}'
-        return sanitize_filename_part(outres)
-
-    def prompt_no_style(self):
-        if self.p is None or self.prompt is None:
-            return None
-
-        prompt_no_style = self.prompt
-        for style in shared.prompt_styles.get_style_prompts(self.p.styles):
-            if style:
-                for part in style.split("{prompt}"):
-                    prompt_no_style = prompt_no_style.replace(part, "").replace(", ,", ",").strip().strip(',')
-
-                prompt_no_style = prompt_no_style.replace(style, "").strip().strip(',').strip()
-
-        return sanitize_filename_part(prompt_no_style, replace_spaces=False)
-
-    def prompt_words(self):
-        words = [x for x in re_nonletters.split(self.prompt or "") if x]
-        if len(words) == 0:
-            words = ["empty"]
-        return sanitize_filename_part(" ".join(words[0:opts.directories_max_prompt_words]), replace_spaces=False)
-
-    def datetime(self, *args):
-        time_datetime = datetime.datetime.now()
-
-        time_format = args[0] if (args and args[0] != "") else self.default_time_format
-        try:
-            time_zone = pytz.timezone(args[1]) if len(args) > 1 else None
-        except pytz.exceptions.UnknownTimeZoneError:
-            time_zone = None
-
-        time_zone_time = time_datetime.astimezone(time_zone)
-        try:
-            formatted_time = time_zone_time.strftime(time_format)
-        except (ValueError, TypeError):
-            formatted_time = time_zone_time.strftime(self.default_time_format)
-
-        return sanitize_filename_part(formatted_time, replace_spaces=False)
-
-    def image_hash(self, *args):
-        length = int(args[0]) if (args and args[0] != "") else None
-        return hashlib.sha256(self.image.tobytes()).hexdigest()[0:length]
-
-    def string_hash(self, text, *args):
-        length = int(args[0]) if (args and args[0] != "") else 8
-        return hashlib.sha256(text.encode()).hexdigest()[0:length]
-
-    def apply(self, x):
-        res = ''
-
-        for m in re_pattern.finditer(x):
-            text, pattern = m.groups()
-
-            if pattern is None:
-                res += text
-                continue
-
-            pattern_args = []
-            while True:
-                m = re_pattern_arg.match(pattern)
-                if m is None:
-                    break
-
-                pattern, arg = m.groups()
-                pattern_args.insert(0, arg)
-
-            fun = self.replacements.get(pattern.lower())
-            if fun is not None:
-                try:
-                    replacement = fun(self, *pattern_args)
-                except Exception:
-                    replacement = None
-                    errors.report(f"Error adding [{pattern}] to filename", exc_info=True)
-
-                if replacement == NOTHING_AND_SKIP_PREVIOUS_TEXT:
-                    continue
-                elif replacement is not None:
-                    res += text + str(replacement)
-                    continue
-
-            res += f'{text}[{pattern}]'
-
-        return res
-
-
-def get_next_sequence_number(path, basename):
-    """
-    Determines and returns the next sequence number to use when saving an image in the specified directory.
-
-    The sequence starts at 0.
-    """
-    result = -1
-    if basename != '':
-        basename = f"{basename}-"
-
-    prefix_length = len(basename)
-    for p in os.listdir(path):
-        if p.startswith(basename):
-            parts = os.path.splitext(p[prefix_length:])[0].split('-')  # splits the filename (removing the basename first if one is defined, so the sequence number is always the first element)
-            try:
-                result = max(int(parts[0]), result)
-            except ValueError:
-                pass
-
-    return result + 1
-
-
-def save_image_with_geninfo(image, geninfo, filename, extension=None, existing_pnginfo=None, pnginfo_section_name='parameters'):
-    """
-    Saves image to filename, including geninfo as text information for generation info.
-    For PNG images, geninfo is added to existing pnginfo dictionary using the pnginfo_section_name argument as key.
-    For JPG images, there's no dictionary and geninfo just replaces the EXIF description.
-    """
-
-    if extension is None:
-        extension = os.path.splitext(filename)[1]
-
-    image_format = Image.registered_extensions()[extension]
-
-    if extension.lower() == '.png':
-        existing_pnginfo = existing_pnginfo or {}
-        if opts.enable_pnginfo:
-            existing_pnginfo[pnginfo_section_name] = geninfo
-
-        if opts.enable_pnginfo:
-            pnginfo_data = PngImagePlugin.PngInfo()
-            for k, v in (existing_pnginfo or {}).items():
-                pnginfo_data.add_text(k, str(v))
-        else:
-            pnginfo_data = None
-
-        image.save(filename, format=image_format, quality=opts.jpeg_quality, pnginfo=pnginfo_data)
-
-    elif extension.lower() in (".jpg", ".jpeg", ".webp"):
-        if image.mode == 'RGBA':
-            image = image.convert("RGB")
-        elif image.mode == 'I;16':
-            image = image.point(lambda p: p * 0.0038910505836576).convert("RGB" if extension.lower() == ".webp" else "L")
-
-        image.save(filename, format=image_format, quality=opts.jpeg_quality, lossless=opts.webp_lossless)
-
-        if opts.enable_pnginfo and geninfo is not None:
-            exif_bytes = piexif.dump({
-                "Exif": {
-                    piexif.ExifIFD.UserComment: piexif.helper.UserComment.dump(geninfo or "", encoding="unicode")
-                },
-            })
-
-            piexif.insert(exif_bytes, filename)
-    else:
-        image.save(filename, format=image_format, quality=opts.jpeg_quality)
-
-
-def save_image(image, path, basename, seed=None, prompt=None, extension='png', info=None, short_filename=False, no_prompt=False, grid=False, pnginfo_section_name='parameters', p=None, existing_info=None, forced_filename=None, suffix="", save_to_dirs=None):
-    """Save an image.
-
-    Args:
-        image (`PIL.Image`):
-            The image to be saved.
-        path (`str`):
-            The directory to save the image. Note, the option `save_to_dirs` will make the image to be saved into a sub directory.
-        basename (`str`):
-            The base filename which will be applied to `filename pattern`.
-        seed, prompt, short_filename,
-        extension (`str`):
-            Image file extension, default is `png`.
-        pngsectionname (`str`):
-            Specify the name of the section which `info` will be saved in.
-        info (`str` or `PngImagePlugin.iTXt`):
-            PNG info chunks.
-        existing_info (`dict`):
-            Additional PNG info. `existing_info == {pngsectionname: info, ...}`
-        no_prompt:
-            TODO I don't know its meaning.
-        p (`StableDiffusionProcessing`)
-        forced_filename (`str`):
-            If specified, `basename` and filename pattern will be ignored.
-        save_to_dirs (bool):
-            If true, the image will be saved into a subdirectory of `path`.
-
-    Returns: (fullfn, txt_fullfn)
-        fullfn (`str`):
-            The full path of the saved imaged.
-        txt_fullfn (`str` or None):
-            If a text file is saved for this image, this will be its full path. Otherwise None.
-    """
-    namegen = FilenameGenerator(p, seed, prompt, image)
-
-    # WebP and JPG formats have maximum dimension limits of 16383 and 65535 respectively. switch to PNG which has a much higher limit
-    if (image.height > 65535 or image.width > 65535) and extension.lower() in ("jpg", "jpeg") or (image.height > 16383 or image.width > 16383) and extension.lower() == "webp":
-        print('Image dimensions too large; saving as PNG')
-        extension = ".png"
-
-    if save_to_dirs is None:
-        save_to_dirs = (grid and opts.grid_save_to_dirs) or (not grid and opts.save_to_dirs and not no_prompt)
-
-    if save_to_dirs:
-        dirname = namegen.apply(opts.directories_filename_pattern or "[prompt_words]").lstrip(' ').rstrip('\\ /')
-        path = os.path.join(path, dirname)
-
-    os.makedirs(path, exist_ok=True)
-
-    if forced_filename is None:
-        if short_filename or seed is None:
-            file_decoration = ""
-        elif opts.save_to_dirs:
-            file_decoration = opts.samples_filename_pattern or "[seed]"
-        else:
-            file_decoration = opts.samples_filename_pattern or "[seed]-[prompt_spaces]"
-
-        file_decoration = namegen.apply(file_decoration) + suffix
-
-        add_number = opts.save_images_add_number or file_decoration == ''
-
-        if file_decoration != "" and add_number:
-            file_decoration = f"-{file_decoration}"
-
-        if add_number:
-            basecount = get_next_sequence_number(path, basename)
-            fullfn = None
-            for i in range(500):
-                fn = f"{basecount + i:05}" if basename == '' else f"{basename}-{basecount + i:04}"
-                fullfn = os.path.join(path, f"{fn}{file_decoration}.{extension}")
-                if not os.path.exists(fullfn):
-                    break
-        else:
-            fullfn = os.path.join(path, f"{file_decoration}.{extension}")
-    else:
-        fullfn = os.path.join(path, f"{forced_filename}.{extension}")
-
-    pnginfo = existing_info or {}
-    if info is not None:
-        pnginfo[pnginfo_section_name] = info
-
-    params = script_callbacks.ImageSaveParams(image, p, fullfn, pnginfo)
-    script_callbacks.before_image_saved_callback(params)
-
-    image = params.image
-    fullfn = params.filename
-    info = params.pnginfo.get(pnginfo_section_name, None)
-
-    def _atomically_save_image(image_to_save, filename_without_extension, extension):
-        """
-        save image with .tmp extension to avoid race condition when another process detects new image in the directory
-        """
-        temp_file_path = f"{filename_without_extension}.tmp"
-
-        save_image_with_geninfo(image_to_save, info, temp_file_path, extension, existing_pnginfo=params.pnginfo, pnginfo_section_name=pnginfo_section_name)
-
-        os.replace(temp_file_path, filename_without_extension + extension)
-
-    fullfn_without_extension, extension = os.path.splitext(params.filename)
-    if hasattr(os, 'statvfs'):
-        max_name_len = os.statvfs(path).f_namemax
-        fullfn_without_extension = fullfn_without_extension[:max_name_len - max(4, len(extension))]
-        params.filename = fullfn_without_extension + extension
-        fullfn = params.filename
-    _atomically_save_image(image, fullfn_without_extension, extension)
-
-    image.already_saved_as = fullfn
-
-    oversize = image.width > opts.target_side_length or image.height > opts.target_side_length
-    if opts.export_for_4chan and (oversize or os.stat(fullfn).st_size > opts.img_downscale_threshold * 1024 * 1024):
-        ratio = image.width / image.height
-        resize_to = None
-        if oversize and ratio > 1:
-            resize_to = round(opts.target_side_length), round(image.height * opts.target_side_length / image.width)
-        elif oversize:
-            resize_to = round(image.width * opts.target_side_length / image.height), round(opts.target_side_length)
-
-        if resize_to is not None:
-            try:
-                # Resizing image with LANCZOS could throw an exception if e.g. image mode is I;16
-                image = image.resize(resize_to, LANCZOS)
-            except Exception:
-                image = image.resize(resize_to)
-        try:
-            _atomically_save_image(image, fullfn_without_extension, ".jpg")
-        except Exception as e:
-            errors.display(e, "saving image as downscaled JPG")
-
-    if opts.save_txt and info is not None:
-        txt_fullfn = f"{fullfn_without_extension}.txt"
-        with open(txt_fullfn, "w", encoding="utf8") as file:
-            file.write(f"{info}\n")
-    else:
-        txt_fullfn = None
-
-    script_callbacks.image_saved_callback(params)
-
-    return fullfn, txt_fullfn
-
-
-IGNORED_INFO_KEYS = {
-    'jfif', 'jfif_version', 'jfif_unit', 'jfif_density', 'dpi', 'exif',
-    'loop', 'background', 'timestamp', 'duration', 'progressive', 'progression',
-    'icc_profile', 'chromaticity', 'photoshop',
-}
-
-
-def read_info_from_image(image: Image.Image) -> tuple[str | None, dict]:
-    items = (image.info or {}).copy()
-
-    geninfo = items.pop('parameters', None)
-
-    if "exif" in items:
-        exif = piexif.load(items["exif"])
-        exif_comment = (exif or {}).get("Exif", {}).get(piexif.ExifIFD.UserComment, b'')
-        try:
-            exif_comment = piexif.helper.UserComment.load(exif_comment)
-        except ValueError:
-            exif_comment = exif_comment.decode('utf8', errors="ignore")
-
-        if exif_comment:
-            items['exif comment'] = exif_comment
-            geninfo = exif_comment
-
-    for field in IGNORED_INFO_KEYS:
-        items.pop(field, None)
-
-    if items.get("Software", None) == "NovelAI":
-        try:
-            json_info = json.loads(items["Comment"])
-            sampler = sd_samplers.samplers_map.get(json_info["sampler"], "Euler a")
-
-            geninfo = f"""{items["Description"]}
-Negative prompt: {json_info["uc"]}
-Steps: {json_info["steps"]}, Sampler: {sampler}, CFG scale: {json_info["scale"]}, Seed: {json_info["seed"]}, Size: {image.width}x{image.height}, Clip skip: 2, ENSD: 31337"""
-        except Exception:
-            errors.report("Error parsing NovelAI image generation parameters", exc_info=True)
-
-    return geninfo, items
-
-
-def image_data(data):
-    import gradio as gr
-
-    try:
-        image = Image.open(io.BytesIO(data))
-        textinfo, _ = read_info_from_image(image)
-        return textinfo, None
-    except Exception:
-        pass
-
-    try:
-        text = data.decode('utf8')
-        assert len(text) < 10000
-        return text, None
-
-    except Exception:
-        pass
-
-    return gr.update(), None
-
-
-def flatten(img, bgcolor):
-    """replaces transparency with bgcolor (example: "#ffffff"), returning an RGB mode image with no transparency"""
-
-    if img.mode == "RGBA":
-        background = Image.new('RGBA', img.size, bgcolor)
-        background.paste(img, mask=img)
-        img = background
-
-    return img.convert('RGB')

modules/scripts.py

@@ -1,758 +0,0 @@
-import os
-import re
-import sys
-import inspect
-from collections import namedtuple
-from dataclasses import dataclass
-
-import gradio as gr
-
-from modules import shared, paths, script_callbacks, extensions, script_loading, scripts_postprocessing, errors, timer
-
-AlwaysVisible = object()
-
-
-class PostprocessImageArgs:
-    def __init__(self, image):
-        self.image = image
-
-
-class PostprocessBatchListArgs:
-    def __init__(self, images):
-        self.images = images
-
-
-@dataclass
-class OnComponent:
-    component: gr.blocks.Block
-
-
-class Script:
-    name = None
-    """script's internal name derived from title"""
-
-    section = None
-    """name of UI section that the script's controls will be placed into"""
-
-    filename = None
-    args_from = None
-    args_to = None
-    alwayson = False
-
-    is_txt2img = False
-    is_img2img = False
-    tabname = None
-
-    group = None
-    """A gr.Group component that has all script's UI inside it."""
-
-    create_group = True
-    """If False, for alwayson scripts, a group component will not be created."""
-
-    infotext_fields = None
-    """if set in ui(), this is a list of pairs of gradio component + text; the text will be used when
-    parsing infotext to set the value for the component; see ui.py's txt2img_paste_fields for an example
-    """
-
-    paste_field_names = None
-    """if set in ui(), this is a list of names of infotext fields; the fields will be sent through the
-    various "Send to <X>" buttons when clicked
-    """
-
-    api_info = None
-    """Generated value of type modules.api.models.ScriptInfo with information about the script for API"""
-
-    on_before_component_elem_id = None
-    """list of callbacks to be called before a component with an elem_id is created"""
-
-    on_after_component_elem_id = None
-    """list of callbacks to be called after a component with an elem_id is created"""
-
-    setup_for_ui_only = False
-    """If true, the script setup will only be run in Gradio UI, not in API"""
-
-    def title(self):
-        """this function should return the title of the script. This is what will be displayed in the dropdown menu."""
-
-        raise NotImplementedError()
-
-    def ui(self, is_img2img):
-        """this function should create gradio UI elements. See https://gradio.app/docs/#components
-        The return value should be an array of all components that are used in processing.
-        Values of those returned components will be passed to run() and process() functions.
-        """
-
-        pass
-
-    def show(self, is_img2img):
-        """
-        is_img2img is True if this function is called for the img2img interface, and Fasle otherwise
-
-        This function should return:
-         - False if the script should not be shown in UI at all
-         - True if the script should be shown in UI if it's selected in the scripts dropdown
-         - script.AlwaysVisible if the script should be shown in UI at all times
-         """
-
-        return True
-
-    def run(self, p, *args):
-        """
-        This function is called if the script has been selected in the script dropdown.
-        It must do all processing and return the Processed object with results, same as
-        one returned by processing.process_images.
-
-        Usually the processing is done by calling the processing.process_images function.
-
-        args contains all values returned by components from ui()
-        """
-
-        pass
-
-    def setup(self, p, *args):
-        """For AlwaysVisible scripts, this function is called when the processing object is set up, before any processing starts.
-        args contains all values returned by components from ui().
-        """
-        pass
-
-
-    def before_process(self, p, *args):
-        """
-        This function is called very early during processing begins for AlwaysVisible scripts.
-        You can modify the processing object (p) here, inject hooks, etc.
-        args contains all values returned by components from ui()
-        """
-
-        pass
-
-    def process(self, p, *args):
-        """
-        This function is called before processing begins for AlwaysVisible scripts.
-        You can modify the processing object (p) here, inject hooks, etc.
-        args contains all values returned by components from ui()
-        """
-
-        pass
-
-    def before_process_batch(self, p, *args, **kwargs):
-        """
-        Called before extra networks are parsed from the prompt, so you can add
-        new extra network keywords to the prompt with this callback.
-
-        **kwargs will have those items:
-          - batch_number - index of current batch, from 0 to number of batches-1
-          - prompts - list of prompts for current batch; you can change contents of this list but changing the number of entries will likely break things
-          - seeds - list of seeds for current batch
-          - subseeds - list of subseeds for current batch
-        """
-
-        pass
-
-    def after_extra_networks_activate(self, p, *args, **kwargs):
-        """
-        Called after extra networks activation, before conds calculation
-        allow modification of the network after extra networks activation been applied
-        won't be call if p.disable_extra_networks
-
-        **kwargs will have those items:
-          - batch_number - index of current batch, from 0 to number of batches-1
-          - prompts - list of prompts for current batch; you can change contents of this list but changing the number of entries will likely break things
-          - seeds - list of seeds for current batch
-          - subseeds - list of subseeds for current batch
-          - extra_network_data - list of ExtraNetworkParams for current stage
-        """
-        pass
-
-    def process_batch(self, p, *args, **kwargs):
-        """
-        Same as process(), but called for every batch.
-
-        **kwargs will have those items:
-          - batch_number - index of current batch, from 0 to number of batches-1
-          - prompts - list of prompts for current batch; you can change contents of this list but changing the number of entries will likely break things
-          - seeds - list of seeds for current batch
-          - subseeds - list of subseeds for current batch
-        """
-
-        pass
-
-    def postprocess_batch(self, p, *args, **kwargs):
-        """
-        Same as process_batch(), but called for every batch after it has been generated.
-
-        **kwargs will have same items as process_batch, and also:
-          - batch_number - index of current batch, from 0 to number of batches-1
-          - images - torch tensor with all generated images, with values ranging from 0 to 1;
-        """
-
-        pass
-
-    def postprocess_batch_list(self, p, pp: PostprocessBatchListArgs, *args, **kwargs):
-        """
-        Same as postprocess_batch(), but receives batch images as a list of 3D tensors instead of a 4D tensor.
-        This is useful when you want to update the entire batch instead of individual images.
-
-        You can modify the postprocessing object (pp) to update the images in the batch, remove images, add images, etc.
-        If the number of images is different from the batch size when returning,
-        then the script has the responsibility to also update the following attributes in the processing object (p):
-          - p.prompts
-          - p.negative_prompts
-          - p.seeds
-          - p.subseeds
-
-        **kwargs will have same items as process_batch, and also:
-          - batch_number - index of current batch, from 0 to number of batches-1
-        """
-
-        pass
-
-    def postprocess_image(self, p, pp: PostprocessImageArgs, *args):
-        """
-        Called for every image after it has been generated.
-        """
-
-        pass
-
-    def postprocess(self, p, processed, *args):
-        """
-        This function is called after processing ends for AlwaysVisible scripts.
-        args contains all values returned by components from ui()
-        """
-
-        pass
-
-    def before_component(self, component, **kwargs):
-        """
-        Called before a component is created.
-        Use elem_id/label fields of kwargs to figure out which component it is.
-        This can be useful to inject your own components somewhere in the middle of vanilla UI.
-        You can return created components in the ui() function to add them to the list of arguments for your processing functions
-        """
-
-        pass
-
-    def after_component(self, component, **kwargs):
-        """
-        Called after a component is created. Same as above.
-        """
-
-        pass
-
-    def on_before_component(self, callback, *, elem_id):
-        """
-        Calls callback before a component is created. The callback function is called with a single argument of type OnComponent.
-
-        May be called in show() or ui() - but it may be too late in latter as some components may already be created.
-
-        This function is an alternative to before_component in that it also cllows to run before a component is created, but
-        it doesn't require to be called for every created component - just for the one you need.
-        """
-        if self.on_before_component_elem_id is None:
-            self.on_before_component_elem_id = []
-
-        self.on_before_component_elem_id.append((elem_id, callback))
-
-    def on_after_component(self, callback, *, elem_id):
-        """
-        Calls callback after a component is created. The callback function is called with a single argument of type OnComponent.
-        """
-        if self.on_after_component_elem_id is None:
-            self.on_after_component_elem_id = []
-
-        self.on_after_component_elem_id.append((elem_id, callback))
-
-    def describe(self):
-        """unused"""
-        return ""
-
-    def elem_id(self, item_id):
-        """helper function to generate id for a HTML element, constructs final id out of script name, tab and user-supplied item_id"""
-
-        need_tabname = self.show(True) == self.show(False)
-        tabkind = 'img2img' if self.is_img2img else 'txt2img'
-        tabname = f"{tabkind}_" if need_tabname else ""
-        title = re.sub(r'[^a-z_0-9]', '', re.sub(r'\s', '_', self.title().lower()))
-
-        return f'script_{tabname}{title}_{item_id}'
-
-    def before_hr(self, p, *args):
-        """
-        This function is called before hires fix start.
-        """
-        pass
-
-
-class ScriptBuiltinUI(Script):
-    setup_for_ui_only = True
-
-    def elem_id(self, item_id):
-        """helper function to generate id for a HTML element, constructs final id out of tab and user-supplied item_id"""
-
-        need_tabname = self.show(True) == self.show(False)
-        tabname = ('img2img' if self.is_img2img else 'txt2img') + "_" if need_tabname else ""
-
-        return f'{tabname}{item_id}'
-
-
-current_basedir = paths.script_path
-
-
-def basedir():
-    """returns the base directory for the current script. For scripts in the main scripts directory,
-    this is the main directory (where webui.py resides), and for scripts in extensions directory
-    (ie extensions/aesthetic/script/aesthetic.py), this is extension's directory (extensions/aesthetic)
-    """
-    return current_basedir
-
-
-ScriptFile = namedtuple("ScriptFile", ["basedir", "filename", "path"])
-
-scripts_data = []
-postprocessing_scripts_data = []
-ScriptClassData = namedtuple("ScriptClassData", ["script_class", "path", "basedir", "module"])
-
-
-def list_scripts(scriptdirname, extension, *, include_extensions=True):
-    scripts_list = []
-
-    basedir = os.path.join(paths.script_path, scriptdirname)
-    if os.path.exists(basedir):
-        for filename in sorted(os.listdir(basedir)):
-            scripts_list.append(ScriptFile(paths.script_path, filename, os.path.join(basedir, filename)))
-
-    if include_extensions:
-        for ext in extensions.active():
-            scripts_list += ext.list_files(scriptdirname, extension)
-
-    scripts_list = [x for x in scripts_list if os.path.splitext(x.path)[1].lower() == extension and os.path.isfile(x.path)]
-
-    return scripts_list
-
-
-def list_files_with_name(filename):
-    res = []
-
-    dirs = [paths.script_path] + [ext.path for ext in extensions.active()]
-
-    for dirpath in dirs:
-        if not os.path.isdir(dirpath):
-            continue
-
-        path = os.path.join(dirpath, filename)
-        if os.path.isfile(path):
-            res.append(path)
-
-    return res
-
-
-def load_scripts():
-    global current_basedir
-    scripts_data.clear()
-    postprocessing_scripts_data.clear()
-    script_callbacks.clear_callbacks()
-
-    scripts_list = list_scripts("scripts", ".py") + list_scripts("modules/processing_scripts", ".py", include_extensions=False)
-
-    syspath = sys.path
-
-    def register_scripts_from_module(module):
-        for script_class in module.__dict__.values():
-            if not inspect.isclass(script_class):
-                continue
-
-            if issubclass(script_class, Script):
-                scripts_data.append(ScriptClassData(script_class, scriptfile.path, scriptfile.basedir, module))
-            elif issubclass(script_class, scripts_postprocessing.ScriptPostprocessing):
-                postprocessing_scripts_data.append(ScriptClassData(script_class, scriptfile.path, scriptfile.basedir, module))
-
-    def orderby(basedir):
-        # 1st webui, 2nd extensions-builtin, 3rd extensions
-        priority = {os.path.join(paths.script_path, "extensions-builtin"):1, paths.script_path:0}
-        for key in priority:
-            if basedir.startswith(key):
-                return priority[key]
-        return 9999
-
-    for scriptfile in sorted(scripts_list, key=lambda x: [orderby(x.basedir), x]):
-        try:
-            if scriptfile.basedir != paths.script_path:
-                sys.path = [scriptfile.basedir] + sys.path
-            current_basedir = scriptfile.basedir
-
-            script_module = script_loading.load_module(scriptfile.path)
-            register_scripts_from_module(script_module)
-
-        except Exception:
-            errors.report(f"Error loading script: {scriptfile.filename}", exc_info=True)
-
-        finally:
-            sys.path = syspath
-            current_basedir = paths.script_path
-            timer.startup_timer.record(scriptfile.filename)
-
-    global scripts_txt2img, scripts_img2img, scripts_postproc
-
-    scripts_txt2img = ScriptRunner()
-    scripts_img2img = ScriptRunner()
-    scripts_postproc = scripts_postprocessing.ScriptPostprocessingRunner()
-
-
-def wrap_call(func, filename, funcname, *args, default=None, **kwargs):
-    try:
-        return func(*args, **kwargs)
-    except Exception:
-        errors.report(f"Error calling: {filename}/{funcname}", exc_info=True)
-
-    return default
-
-
-class ScriptRunner:
-    def __init__(self):
-        self.scripts = []
-        self.selectable_scripts = []
-        self.alwayson_scripts = []
-        self.titles = []
-        self.title_map = {}
-        self.infotext_fields = []
-        self.paste_field_names = []
-        self.inputs = [None]
-
-        self.on_before_component_elem_id = {}
-        """dict of callbacks to be called before an element is created; key=elem_id, value=list of callbacks"""
-
-        self.on_after_component_elem_id = {}
-        """dict of callbacks to be called after an element is created; key=elem_id, value=list of callbacks"""
-
-    def initialize_scripts(self, is_img2img):
-        from modules import scripts_auto_postprocessing
-
-        self.scripts.clear()
-        self.alwayson_scripts.clear()
-        self.selectable_scripts.clear()
-
-        auto_processing_scripts = scripts_auto_postprocessing.create_auto_preprocessing_script_data()
-
-        for script_data in auto_processing_scripts + scripts_data:
-            script = script_data.script_class()
-            script.filename = script_data.path
-            script.is_txt2img = not is_img2img
-            script.is_img2img = is_img2img
-            script.tabname = "img2img" if is_img2img else "txt2img"
-
-            visibility = script.show(script.is_img2img)
-
-            if visibility == AlwaysVisible:
-                self.scripts.append(script)
-                self.alwayson_scripts.append(script)
-                script.alwayson = True
-
-            elif visibility:
-                self.scripts.append(script)
-                self.selectable_scripts.append(script)
-
-        self.apply_on_before_component_callbacks()
-
-    def apply_on_before_component_callbacks(self):
-        for script in self.scripts:
-            on_before = script.on_before_component_elem_id or []
-            on_after = script.on_after_component_elem_id or []
-
-            for elem_id, callback in on_before:
-                if elem_id not in self.on_before_component_elem_id:
-                    self.on_before_component_elem_id[elem_id] = []
-
-                self.on_before_component_elem_id[elem_id].append((callback, script))
-
-            for elem_id, callback in on_after:
-                if elem_id not in self.on_after_component_elem_id:
-                    self.on_after_component_elem_id[elem_id] = []
-
-                self.on_after_component_elem_id[elem_id].append((callback, script))
-
-            on_before.clear()
-            on_after.clear()
-
-    def create_script_ui(self, script):
-        import modules.api.models as api_models
-
-        script.args_from = len(self.inputs)
-        script.args_to = len(self.inputs)
-
-        controls = wrap_call(script.ui, script.filename, "ui", script.is_img2img)
-
-        if controls is None:
-            return
-
-        script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
-        api_args = []
-
-        for control in controls:
-            control.custom_script_source = os.path.basename(script.filename)
-
-            arg_info = api_models.ScriptArg(label=control.label or "")
-
-            for field in ("value", "minimum", "maximum", "step", "choices"):
-                v = getattr(control, field, None)
-                if v is not None:
-                    setattr(arg_info, field, v)
-
-            api_args.append(arg_info)
-
-        script.api_info = api_models.ScriptInfo(
-            name=script.name,
-            is_img2img=script.is_img2img,
-            is_alwayson=script.alwayson,
-            args=api_args,
-        )
-
-        if script.infotext_fields is not None:
-            self.infotext_fields += script.infotext_fields
-
-        if script.paste_field_names is not None:
-            self.paste_field_names += script.paste_field_names
-
-        self.inputs += controls
-        script.args_to = len(self.inputs)
-
-    def setup_ui_for_section(self, section, scriptlist=None):
-        if scriptlist is None:
-            scriptlist = self.alwayson_scripts
-
-        for script in scriptlist:
-            if script.alwayson and script.section != section:
-                continue
-
-            if script.create_group:
-                with gr.Group(visible=script.alwayson) as group:
-                    self.create_script_ui(script)
-
-                script.group = group
-            else:
-                self.create_script_ui(script)
-
-    def prepare_ui(self):
-        self.inputs = [None]
-
-    def setup_ui(self):
-        all_titles = [wrap_call(script.title, script.filename, "title") or script.filename for script in self.scripts]
-        self.title_map = {title.lower(): script for title, script in zip(all_titles, self.scripts)}
-        self.titles = [wrap_call(script.title, script.filename, "title") or f"{script.filename} [error]" for script in self.selectable_scripts]
-
-        self.setup_ui_for_section(None)
-
-        dropdown = gr.Dropdown(label="Script", elem_id="script_list", choices=["None"] + self.titles, value="None", type="index")
-        self.inputs[0] = dropdown
-
-        self.setup_ui_for_section(None, self.selectable_scripts)
-
-        def select_script(script_index):
-            selected_script = self.selectable_scripts[script_index - 1] if script_index>0 else None
-
-            return [gr.update(visible=selected_script == s) for s in self.selectable_scripts]
-
-        def init_field(title):
-            """called when an initial value is set from ui-config.json to show script's UI components"""
-
-            if title == 'None':
-                return
-
-            script_index = self.titles.index(title)
-            self.selectable_scripts[script_index].group.visible = True
-
-        dropdown.init_field = init_field
-
-        dropdown.change(
-            fn=select_script,
-            inputs=[dropdown],
-            outputs=[script.group for script in self.selectable_scripts]
-        )
-
-        self.script_load_ctr = 0
-
-        def onload_script_visibility(params):
-            title = params.get('Script', None)
-            if title:
-                title_index = self.titles.index(title)
-                visibility = title_index == self.script_load_ctr
-                self.script_load_ctr = (self.script_load_ctr + 1) % len(self.titles)
-                return gr.update(visible=visibility)
-            else:
-                return gr.update(visible=False)
-
-        self.infotext_fields.append((dropdown, lambda x: gr.update(value=x.get('Script', 'None'))))
-        self.infotext_fields.extend([(script.group, onload_script_visibility) for script in self.selectable_scripts])
-
-        self.apply_on_before_component_callbacks()
-
-        return self.inputs
-
-    def run(self, p, *args):
-        script_index = args[0]
-
-        if script_index == 0:
-            return None
-
-        script = self.selectable_scripts[script_index-1]
-
-        if script is None:
-            return None
-
-        script_args = args[script.args_from:script.args_to]
-        processed = script.run(p, *script_args)
-
-        shared.total_tqdm.clear()
-
-        return processed
-
-    def before_process(self, p):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.before_process(p, *script_args)
-            except Exception:
-                errors.report(f"Error running before_process: {script.filename}", exc_info=True)
-
-    def process(self, p):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.process(p, *script_args)
-            except Exception:
-                errors.report(f"Error running process: {script.filename}", exc_info=True)
-
-    def before_process_batch(self, p, **kwargs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.before_process_batch(p, *script_args, **kwargs)
-            except Exception:
-                errors.report(f"Error running before_process_batch: {script.filename}", exc_info=True)
-
-    def after_extra_networks_activate(self, p, **kwargs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.after_extra_networks_activate(p, *script_args, **kwargs)
-            except Exception:
-                errors.report(f"Error running after_extra_networks_activate: {script.filename}", exc_info=True)
-
-    def process_batch(self, p, **kwargs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.process_batch(p, *script_args, **kwargs)
-            except Exception:
-                errors.report(f"Error running process_batch: {script.filename}", exc_info=True)
-
-    def postprocess(self, p, processed):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.postprocess(p, processed, *script_args)
-            except Exception:
-                errors.report(f"Error running postprocess: {script.filename}", exc_info=True)
-
-    def postprocess_batch(self, p, images, **kwargs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.postprocess_batch(p, *script_args, images=images, **kwargs)
-            except Exception:
-                errors.report(f"Error running postprocess_batch: {script.filename}", exc_info=True)
-
-    def postprocess_batch_list(self, p, pp: PostprocessBatchListArgs, **kwargs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.postprocess_batch_list(p, pp, *script_args, **kwargs)
-            except Exception:
-                errors.report(f"Error running postprocess_batch_list: {script.filename}", exc_info=True)
-
-    def postprocess_image(self, p, pp: PostprocessImageArgs):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.postprocess_image(p, pp, *script_args)
-            except Exception:
-                errors.report(f"Error running postprocess_image: {script.filename}", exc_info=True)
-
-    def before_component(self, component, **kwargs):
-        for callback, script in self.on_before_component_elem_id.get(kwargs.get("elem_id"), []):
-            try:
-                callback(OnComponent(component=component))
-            except Exception:
-                errors.report(f"Error running on_before_component: {script.filename}", exc_info=True)
-
-        for script in self.scripts:
-            try:
-                script.before_component(component, **kwargs)
-            except Exception:
-                errors.report(f"Error running before_component: {script.filename}", exc_info=True)
-
-    def after_component(self, component, **kwargs):
-        for callback, script in self.on_after_component_elem_id.get(component.elem_id, []):
-            try:
-                callback(OnComponent(component=component))
-            except Exception:
-                errors.report(f"Error running on_after_component: {script.filename}", exc_info=True)
-
-        for script in self.scripts:
-            try:
-                script.after_component(component, **kwargs)
-            except Exception:
-                errors.report(f"Error running after_component: {script.filename}", exc_info=True)
-
-    def script(self, title):
-        return self.title_map.get(title.lower())
-
-    def reload_sources(self, cache):
-        for si, script in list(enumerate(self.scripts)):
-            args_from = script.args_from
-            args_to = script.args_to
-            filename = script.filename
-
-            module = cache.get(filename, None)
-            if module is None:
-                module = script_loading.load_module(script.filename)
-                cache[filename] = module
-
-            for script_class in module.__dict__.values():
-                if type(script_class) == type and issubclass(script_class, Script):
-                    self.scripts[si] = script_class()
-                    self.scripts[si].filename = filename
-                    self.scripts[si].args_from = args_from
-                    self.scripts[si].args_to = args_to
-
-    def before_hr(self, p):
-        for script in self.alwayson_scripts:
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.before_hr(p, *script_args)
-            except Exception:
-                errors.report(f"Error running before_hr: {script.filename}", exc_info=True)
-
-    def setup_scrips(self, p, *, is_ui=True):
-        for script in self.alwayson_scripts:
-            if not is_ui and script.setup_for_ui_only:
-                continue
-
-            try:
-                script_args = p.script_args[script.args_from:script.args_to]
-                script.setup(p, *script_args)
-            except Exception:
-                errors.report(f"Error running setup: {script.filename}", exc_info=True)
-
-
-scripts_txt2img: ScriptRunner = None
-scripts_img2img: ScriptRunner = None
-scripts_postproc: scripts_postprocessing.ScriptPostprocessingRunner = None
-scripts_current: ScriptRunner = None
-
-
-def reload_script_body_only():
-    cache = {}
-    scripts_txt2img.reload_sources(cache)
-    scripts_img2img.reload_sources(cache)
-
-
-reload_scripts = load_scripts  # compatibility alias

modules/shared.py

@@ -1,87 +0,0 @@
-import sys
-
-import gradio as gr
-
-from modules import shared_cmd_options, shared_gradio_themes, options, shared_items, sd_models_types
-from modules.paths_internal import models_path, script_path, data_path, sd_configs_path, sd_default_config, sd_model_file, default_sd_model_file, extensions_dir, extensions_builtin_dir  # noqa: F401
-from modules import util
-
-cmd_opts = shared_cmd_options.cmd_opts
-parser = shared_cmd_options.parser
-
-batch_cond_uncond = True  # old field, unused now in favor of shared.opts.batch_cond_uncond
-parallel_processing_allowed = True
-styles_filename = cmd_opts.styles_file
-config_filename = cmd_opts.ui_settings_file
-hide_dirs = {"visible": not cmd_opts.hide_ui_dir_config}
-
-demo = None
-
-device = None
-
-weight_load_location = None
-
-xformers_available = False
-
-hypernetworks = {}
-
-loaded_hypernetworks = []
-
-state = None
-
-prompt_styles = None
-
-interrogator = None
-
-face_restorers = []
-
-options_templates = None
-opts = None
-restricted_opts = None
-
-sd_model: sd_models_types.WebuiSdModel = None
-
-settings_components = None
-"""assinged from ui.py, a mapping on setting names to gradio components repsponsible for those settings"""
-
-tab_names = []
-
-latent_upscale_default_mode = "Latent"
-latent_upscale_modes = {
-    "Latent": {"mode": "bilinear", "antialias": False},
-    "Latent (antialiased)": {"mode": "bilinear", "antialias": True},
-    "Latent (bicubic)": {"mode": "bicubic", "antialias": False},
-    "Latent (bicubic antialiased)": {"mode": "bicubic", "antialias": True},
-    "Latent (nearest)": {"mode": "nearest", "antialias": False},
-    "Latent (nearest-exact)": {"mode": "nearest-exact", "antialias": False},
-}
-
-sd_upscalers = []
-
-clip_model = None
-
-progress_print_out = sys.stdout
-
-gradio_theme = gr.themes.Base()
-
-total_tqdm = None
-
-mem_mon = None
-
-options_section = options.options_section
-OptionInfo = options.OptionInfo
-OptionHTML = options.OptionHTML
-
-natural_sort_key = util.natural_sort_key
-listfiles = util.listfiles
-html_path = util.html_path
-html = util.html
-walk_files = util.walk_files
-ldm_print = util.ldm_print
-
-reload_gradio_theme = shared_gradio_themes.reload_gradio_theme
-
-list_checkpoint_tiles = shared_items.list_checkpoint_tiles
-refresh_checkpoints = shared_items.refresh_checkpoints
-list_samplers = shared_items.list_samplers
-reload_hypernetworks = shared_items.reload_hypernetworks