Merge branch 'dev' into better-status-reporting-1

        canvas_hotkey_move: "KeyF",

        canvas_hotkey_overlap: "KeyO",

        canvas_disabled_functions: [],

        canvas_show_tooltip: true

        canvas_show_tooltip: true,

        canvas_blur_prompt: false

    };

    const functionMap = {

        // Handle keydown events

        function handleKeyDown(event) {

            // Disable key locks to make pasting from the buffer work correctly

            if ((event.ctrlKey && event.code === 'KeyV') || (event.ctrlKey && event.code === 'KeyC') || event.code === "F5") {

                return;

            }

            // before activating shortcut, ensure user is not actively typing in an input field

            if (!hotkeysConfig.canvas_blur_prompt) {

                if (event.target.nodeName === 'TEXTAREA' || event.target.nodeName === 'INPUT') {

                    return;

                }

            }

            const hotkeyActions = {

                [hotkeysConfig.canvas_hotkey_reset]: resetZoom,

                [hotkeysConfig.canvas_hotkey_overlap]: toggleOverlap,

        // Handle the move event for pan functionality. Updates the panX and panY variables and applies the new transform to the target element.

        function handleMoveKeyDown(e) {

            // Disable key locks to make pasting from the buffer work correctly

            if ((e.ctrlKey && e.code === 'KeyV') || (e.ctrlKey && event.code === 'KeyC') || e.code === "F5") {

                return;

            }

            // before activating shortcut, ensure user is not actively typing in an input field

            if (!hotkeysConfig.canvas_blur_prompt) {

                if (e.target.nodeName === 'TEXTAREA' || e.target.nodeName === 'INPUT') {

                    return;

                }

            }

            if (e.code === hotkeysConfig.canvas_hotkey_move) {

                if (!e.ctrlKey && !e.metaKey && isKeyDownHandlerAttached) {

                    e.preventDefault();

    "canvas_hotkey_reset": shared.OptionInfo("R", "Reset zoom and canvas positon"),

    "canvas_hotkey_overlap": shared.OptionInfo("O", "Toggle overlap").info("Technical button, neededs for testing"),

    "canvas_show_tooltip": shared.OptionInfo(True, "Enable tooltip on the canvas"),

    "canvas_blur_prompt": shared.OptionInfo(False, "Take the focus off the prompt when working with a canvas"),

    "canvas_disabled_functions": shared.OptionInfo(["Overlap"], "Disable function that you don't use", gr.CheckboxGroup, {"choices": ["Zoom","Adjust brush size", "Moving canvas","Fullscreen","Reset Zoom","Overlap"]}),

}))

from typing import Dict, List, Any

import piexif

import piexif.helper

from contextlib import closing

def script_name_to_index(name, scripts):

            image.save(output_bytes, format="PNG", pnginfo=(metadata if use_metadata else None), quality=opts.jpeg_quality)

        elif opts.samples_format.lower() in ("jpg", "jpeg", "webp"):

            if image.mode == "RGBA":

                image = image.convert("RGB")

            parameters = image.info.get('parameters', None)

            exif_bytes = piexif.dump({

                "Exif": { piexif.ExifIFD.UserComment: piexif.helper.UserComment.dump(parameters or "", encoding="unicode") }

        args.pop('save_images', None)

        with self.queue_lock:

            p = StableDiffusionProcessingTxt2Img(sd_model=shared.sd_model, **args)

            with closing(StableDiffusionProcessingTxt2Img(sd_model=shared.sd_model, **args)) as p:

                p.scripts = script_runner

                p.outpath_grids = opts.outdir_txt2img_grids

                p.outpath_samples = opts.outdir_txt2img_samples

        args.pop('save_images', None)

        with self.queue_lock:

            p = StableDiffusionProcessingImg2Img(sd_model=shared.sd_model, **args)

            with closing(StableDiffusionProcessingImg2Img(sd_model=shared.sd_model, **args)) as p:

                p.init_images = [decode_base64_to_image(x) for x in init_images]

                p.scripts = script_runner

                p.outpath_grids = opts.outdir_img2img_grids

from __future__ import annotations

import datetime

import pytz

    return result + 1

def save_image_with_geninfo(image, geninfo, filename, extension=None, existing_pnginfo=None):

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

        """

        temp_file_path = f"{filename_without_extension}.tmp"

        save_image_with_geninfo(image_to_save, info, temp_file_path, extension, params.pnginfo)

        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)

    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:

            image = image.resize((round(opts.target_side_length), round(image.height * opts.target_side_length / image.width)), LANCZOS)

            resize_to = round(opts.target_side_length), round(image.height * opts.target_side_length / image.width)

        elif oversize:

            image = image.resize((round(image.width * opts.target_side_length / image.height), round(opts.target_side_length)), LANCZOS)

            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:

                image = image.resize(resize_to)

        try:

            _atomically_save_image(image, fullfn_without_extension, ".jpg")

        except Exception as e:

    return fullfn, txt_fullfn

def read_info_from_image(image):

    items = image.info or {}

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)

            items['exif comment'] = exif_comment

            geninfo = exif_comment

    for field in ['jfif', 'jfif_version', 'jfif_unit', 'jfif_density', 'dpi', 'exif',

                    'loop', 'background', 'timestamp', 'duration', 'progressive', 'progression',

                    'icc_profile', 'chromaticity']:

    for field in IGNORED_INFO_KEYS:

        items.pop(field, None)

    if items.get("Software", None) == "NovelAI":

from packaging import version

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

# check `getattr` and try it for compatibility

# before torch version 1.13, has_mps is only available in nightly pytorch and macOS 12.3+,

# use check `getattr` and try it for compatibility.

# in torch version 1.13, backends.mps.is_available() and backends.mps.is_built() are introduced in to check mps availabilty,

# since torch 2.0.1+ nightly build, getattr(torch, 'has_mps', False) was deprecated, see https://github.com/pytorch/pytorch/pull/103279

def check_for_mps() -> bool:

    if version.parse(torch.__version__) <= version.parse("2.0.1"):

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

            return False

        try:

            return True

        except Exception:

            return False

    else:

        return torch.backends.mps.is_available() and torch.backends.mps.is_built()

has_mps = check_for_mps()