gradio4

function create_submit_args(args) {

    var res = Array.from(args);

    // As it is currently, txt2img and img2img send back the previous output args (txt2img_gallery, generation_info, html_info) whenever you generate a new image.

    // This can lead to uploading a huge gallery of previously generated images, which leads to an unnecessary delay between submitting and beginning to generate.

    // I don't know why gradio is sending outputs along with inputs, but we can prevent sending the image gallery here, which seems to be an issue for some.

    // If gradio at some point stops sending outputs, this may break something

    if (Array.isArray(res[res.length - 3])) {

        res[res.length - 3] = null;

    }

    return res;

}

    res[0] = id;

    console.log(res);

    return res;

}

        self.router = APIRouter()

        self.app = app

        self.queue_lock = queue_lock

        api_middleware(self.app)

        #api_middleware(self.app)  # XXX this will have to be fixed

        self.add_api_route("/sdapi/v1/txt2img", self.text2imgapi, methods=["POST"], response_model=models.TextToImageResponse)

        self.add_api_route("/sdapi/v1/img2img", self.img2imgapi, methods=["POST"], response_model=models.ImageToImageResponse)

        self.add_api_route("/sdapi/v1/extra-single-image", self.extras_single_image_api, methods=["POST"], response_model=models.ExtrasSingleImageResponse)

import inspect

from pydantic import BaseModel, Field, create_model

from pydantic import BaseModel, Field, create_model, ConfigDict

from typing import Any, Optional, Literal

from inflection import underscore

from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img

        fields = {

            d.field: (d.field_type, Field(default=d.field_value, alias=d.field_alias, exclude=d.field_exclude)) for d in self._model_def

        }

        DynamicModel = create_model(self._model_name, **fields)

        DynamicModel.__config__.allow_population_by_field_name = True

        DynamicModel.__config__.allow_mutation = True

        DynamicModel = create_model(self._model_name, __config__=ConfigDict(populate_by_name=True, frozen=True), **fields)

        return DynamicModel

StableDiffusionTxt2ImgProcessingAPI = PydanticModelGenerator(

    options: dict[str, str] = Field(title="Options")

class UpscalerItem(BaseModel):

    class Config:

        protected_namespaces = ()

    name: str = Field(title="Name")

    model_name: Optional[str] = Field(title="Model Name")

    model_path: Optional[str] = Field(title="Path")

    name: str = Field(title="Name")

class SDModelItem(BaseModel):

    class Config:

        protected_namespaces = ()

    title: str = Field(title="Title")

    model_name: str = Field(title="Model Name")

    hash: Optional[str] = Field(title="Short hash")

    config: Optional[str] = Field(title="Config file")

class SDVaeItem(BaseModel):

    class Config:

        protected_namespaces = ()

    model_name: str = Field(title="Model Name")

    filename: str = Field(title="Filename")

    expected_torch_version = "2.0.0"

    expected_xformers_version = "0.0.20"

    expected_gradio_version = "3.41.2"

    expected_gradio_version = "4.7.1"

    if version.parse(torch.__version__) < version.parse(expected_torch_version):

        print_error_explanation(f"""

import inspect

import warnings

from functools import wraps

import gradio as gr

import gradio.component_meta

from modules import scripts, ui_tempdir, patches

class GradioDeprecationWarning(DeprecationWarning):

    pass

def add_classes_to_gradio_component(comp):

    """

    this adds gradio-* to the component for css styling (ie gradio-button to gr.Button), as well as some others

    """

    comp.elem_classes = [f"gradio-{comp.get_block_name()}", *(comp.elem_classes or [])]

    comp.elem_classes = [f"gradio-{comp.get_block_name()}", *(getattr(comp, 'elem_classes', None) or [])]

    if getattr(comp, 'multiselect', False):

        comp.elem_classes.append('multiselect')

    return config

original_IOComponent_init = patches.patch(__name__, obj=gr.components.IOComponent, field="__init__", replacement=IOComponent_init)

original_IOComponent_init = patches.patch(__name__, obj=gr.components.Component, field="__init__", replacement=IOComponent_init)

original_Block_get_config = patches.patch(__name__, obj=gr.blocks.Block, field="get_config", replacement=Block_get_config)

original_BlockContext_init = patches.patch(__name__, obj=gr.blocks.BlockContext, field="__init__", replacement=BlockContext_init)

original_Blocks_get_config_file = patches.patch(__name__, obj=gr.blocks.Blocks, field="get_config_file", replacement=Blocks_get_config_file)

ui_tempdir.install_ui_tempdir_override()

def gradio_component_meta_create_or_modify_pyi(component_class, class_name, events):

    if hasattr(component_class, 'webui_do_not_create_gradio_pyi_thank_you'):

        return

    gradio_component_meta_create_or_modify_pyi_original(component_class, class_name, events)

# this prevents creation of .pyi files in webui dir

gradio_component_meta_create_or_modify_pyi_original = patches.patch(__file__, gradio.component_meta, 'create_or_modify_pyi', gradio_component_meta_create_or_modify_pyi)

# this function is broken and does not seem to do anything useful

gradio.component_meta.updateable = lambda x: x

def repair(grclass):

    if not getattr(grclass, 'EVENTS', None):

        return

    @wraps(grclass.__init__)

    def __repaired_init__(self, *args, tooltip=None, source=None, original=grclass.__init__, **kwargs):

        if source:

            kwargs["sources"] = [source]

        allowed_kwargs = inspect.signature(original).parameters

        fixed_kwargs = {}

        for k, v in kwargs.items():

            if k in allowed_kwargs:

                fixed_kwargs[k] = v

            else:

                warnings.warn(f"unexpected argument for {grclass.__name__}: {k}", GradioDeprecationWarning, stacklevel=2)

        original(self, *args, **fixed_kwargs)

        self.webui_tooltip = tooltip

        for event in self.EVENTS:

            replaced_event = getattr(self, str(event))

            def fun(*xargs, _js=None, replaced_event=replaced_event, **xkwargs):

                if _js:

                    xkwargs['js'] = _js

                return replaced_event(*xargs, **xkwargs)

            setattr(self, str(event), fun)

    grclass.__init__ = __repaired_init__

    grclass.update = gr.update

for component in set(gr.components.__all__ + gr.layouts.__all__):

    repair(getattr(gr, component, None))

class Dependency(gr.events.Dependency):

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        def then(*xargs, _js=None, **xkwargs):

            if _js:

                xkwargs['js'] = _js

            return original_then(*xargs, **xkwargs)

        original_then = self.then

        self.then = then

gr.events.Dependency = Dependency

gr.Box = gr.Group