Removed changes in some scripts since the arguments for soft painting are no...

import modules.processing as processing

from modules.ui import plaintext_to_html

import modules.scripts

import modules.soft_inpainting as si

def process_batch(p, input_dir, output_dir, inpaint_mask_dir, args, to_scale=False, scale_by=1.0, use_png_info=False, png_info_props=None, png_info_dir=None):

    return batch_results

def img2img(id_task: str,

            mode: int,

            prompt: str,

            negative_prompt: str,

            prompt_styles,

            init_img,

            sketch,

            init_img_with_mask,

            inpaint_color_sketch,

            inpaint_color_sketch_orig,

            init_img_inpaint,

            init_mask_inpaint,

            steps: int,

            sampler_name: str,

            mask_blur: int,

            mask_alpha: float,

            mask_blend_enabled: bool,

            mask_blend_power: float,

            mask_blend_scale: float,

            inpaint_detail_preservation: float,

            inpainting_fill: int,

            n_iter: int,

            batch_size: int,

            cfg_scale: float,

            image_cfg_scale: float,

            denoising_strength: float,

            selected_scale_tab: int,

            height: int,

            width: int,

            scale_by: float,

            resize_mode: int,

            inpaint_full_res: bool,

            inpaint_full_res_padding: int,

            inpainting_mask_invert: int,

            img2img_batch_input_dir: str,

            img2img_batch_output_dir: str,

            img2img_batch_inpaint_mask_dir: str,

            override_settings_texts,

            img2img_batch_use_png_info: bool,

            img2img_batch_png_info_props: list,

            img2img_batch_png_info_dir: str,

            request: gr.Request, *args):

def img2img(id_task: str, mode: int, prompt: str, negative_prompt: str, prompt_styles, init_img, sketch, init_img_with_mask, inpaint_color_sketch, inpaint_color_sketch_orig, init_img_inpaint, init_mask_inpaint, steps: int, sampler_name: str, mask_blur: int, mask_alpha: float, inpainting_fill: int, n_iter: int, batch_size: int, cfg_scale: float, image_cfg_scale: float, denoising_strength: float, selected_scale_tab: int, height: int, width: int, scale_by: float, resize_mode: int, inpaint_full_res: bool, inpaint_full_res_padding: int, inpainting_mask_invert: int, img2img_batch_input_dir: str, img2img_batch_output_dir: str, img2img_batch_inpaint_mask_dir: str, override_settings_texts, img2img_batch_use_png_info: bool, img2img_batch_png_info_props: list, img2img_batch_png_info_dir: str, request: gr.Request, *args):

    override_settings = create_override_settings_dict(override_settings_texts)

    is_batch = mode == 5

    assert 0. <= denoising_strength <= 1., 'can only work with strength in [0.0, 1.0]'

    soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \

        if mask_blend_enabled else None

    p = StableDiffusionProcessingImg2Img(

        sd_model=shared.sd_model,

        outpath_samples=opts.outdir_samples or opts.outdir_img2img_samples,

        init_images=[image],

        mask=mask,

        mask_blur=mask_blur,

        soft_inpainting=soft_inpainting,

        inpainting_fill=inpainting_fill,

        resize_mode=resize_mode,

        denoising_strength=denoising_strength,

    if mask:

        p.extra_generation_params["Mask blur"] = mask_blur

        if soft_inpainting is not None:

            soft_inpainting.add_generation_params(p.extra_generation_params)

    with closing(p):

        if is_batch:

from modules import prompt_parser

from modules.sd_hijack import model_hijack

from modules.generation_parameters_copypaste import image_from_url_text

import modules.soft_inpainting as si

create_setting_component = ui_settings.create_setting_component

                                mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id="img2img_mask_blur")

                                mask_alpha = gr.Slider(label="Mask transparency", visible=False, elem_id="img2img_mask_alpha")

                            with FormRow():

                                soft_inpainting = si.gradio_ui()

                            with FormRow():

                                inpainting_mask_invert = gr.Radio(label='Mask mode', choices=['Inpaint masked', 'Inpaint not masked'], value='Inpaint masked', type="index", elem_id="img2img_mask_mode")

                    sampler_name,

                    mask_blur,

                    mask_alpha,

                    *(soft_inpainting[0]),

                    inpainting_fill,

                    batch_count,

                    batch_size,

                (toprow.ui_styles.dropdown, lambda d: d["Styles array"] if isinstance(d.get("Styles array"), list) else gr.update()),

                (denoising_strength, "Denoising strength"),

                (mask_blur, "Mask blur"),

                *(soft_inpainting[1]),

                *scripts.scripts_img2img.infotext_fields

            ]

            parameters_copypaste.add_paste_fields("img2img", init_img, img2img_paste_fields, override_settings)

            parameters_copypaste.add_paste_fields("inpaint", init_img_with_mask, img2img_paste_fields, override_settings)

            parameters_copypaste.register_paste_params_button(parameters_copypaste.ParamBinding(

from modules import images

from modules.processing import Processed, process_images

from modules.shared import opts, state

import modules.soft_inpainting as si

# this function is taken from https://github.com/parlance-zz/g-diffuser-bot

        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))

        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=8, elem_id=self.elem_id("mask_blur"))

        soft_inpainting = si.gradio_ui()[0]

        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))

        noise_q = gr.Slider(label="Fall-off exponent (lower=higher detail)", minimum=0.0, maximum=4.0, step=0.01, value=1.0, elem_id=self.elem_id("noise_q"))

        color_variation = gr.Slider(label="Color variation", minimum=0.0, maximum=1.0, step=0.01, value=0.05, elem_id=self.elem_id("color_variation"))

        return [info, pixels, mask_blur, *soft_inpainting, direction, noise_q, color_variation]

        return [info, pixels, mask_blur, direction, noise_q, color_variation]

    def run(self, p, _, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation):

    def run(self, p, _, pixels, mask_blur, direction, noise_q, color_variation):

        initial_seed_and_info = [None, None]

        process_width = p.width

        p.mask_blur_x = mask_blur_x*4

        p.mask_blur_y = mask_blur_y*4

        p.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \

            if mask_blend_enabled else None

        init_img = p.init_images[0]

        target_w = math.ceil((init_img.width + left + right) / 64) * 64

        target_h = math.ceil((init_img.height + up + down) / 64) * 64

from modules import images, devices

from modules.processing import Processed, process_images

from modules.shared import opts, state

import modules.soft_inpainting as si

class Script(scripts.Script):

        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))

        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))

        soft_inpainting = si.gradio_ui()[0]

        inpainting_fill = gr.Radio(label='Masked content', choices=['fill', 'original', 'latent noise', 'latent nothing'], value='fill', type="index", elem_id=self.elem_id("inpainting_fill"))

        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))

        return [pixels, mask_blur, *soft_inpainting, inpainting_fill, direction]

        return [pixels, mask_blur, inpainting_fill, direction]

    def run(self, p, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction):

    def run(self, p, pixels, mask_blur, inpainting_fill, direction):

        initial_seed = None

        initial_info = None

        p.mask_blur = mask_blur * 2

        p.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \

            if mask_blend_enabled else None

        p.inpainting_fill = inpainting_fill

        p.inpaint_full_res = False

import pytest

import requests

import modules.soft_inpainting as si

@pytest.fixture()

        "inpainting_mask_invert": False,

        "mask": None,

        "mask_blur": 4,

        "mask_blend_enabled": True,

        "mask_blend_power": si.default.mask_blend_power,

        "mask_blend_scale": si.default.mask_blend_scale,

        "inpaint_detail_preservation": si.default.inpaint_detail_preservation,

        "n_iter": 1,

        "negative_prompt": "",

        "override_settings": {},