Merge branch 'dev' into test-fp8

    return res;

}

function submit_extras() {

    showSubmitButtons('extras', false);

    var id = randomId();

    requestProgress(id, gradioApp().getElementById('extras_gallery_container'), gradioApp().getElementById('extras_gallery'), function() {

        showSubmitButtons('extras', true);

    });

    var res = create_submit_args(arguments);

    res[0] = id;

    console.log(res);

    return res;

}

function restoreProgressTxt2img() {

    showRestoreProgressButton("txt2img", false);

    var id = localGet("txt2img_task_id");

from modules.shared import opts

from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img, process_images

from modules.textual_inversion.textual_inversion import create_embedding, train_embedding

from modules.textual_inversion.preprocess import preprocess

from modules.hypernetworks.hypernetwork import create_hypernetwork, train_hypernetwork

from PIL import PngImagePlugin, Image

from modules.sd_models_config import find_checkpoint_config_near_filename

        self.add_api_route("/sdapi/v1/refresh-vae", self.refresh_vae, methods=["POST"])

        self.add_api_route("/sdapi/v1/create/embedding", self.create_embedding, methods=["POST"], response_model=models.CreateResponse)

        self.add_api_route("/sdapi/v1/create/hypernetwork", self.create_hypernetwork, methods=["POST"], response_model=models.CreateResponse)

        self.add_api_route("/sdapi/v1/preprocess", self.preprocess, methods=["POST"], response_model=models.PreprocessResponse)

        self.add_api_route("/sdapi/v1/train/embedding", self.train_embedding, methods=["POST"], response_model=models.TrainResponse)

        self.add_api_route("/sdapi/v1/train/hypernetwork", self.train_hypernetwork, methods=["POST"], response_model=models.TrainResponse)

        self.add_api_route("/sdapi/v1/memory", self.get_memory, methods=["GET"], response_model=models.MemoryResponse)

        finally:

            shared.state.end()

    def preprocess(self, args: dict):

        try:

            shared.state.begin(job="preprocess")

            preprocess(**args) # quick operation unless blip/booru interrogation is enabled

            shared.state.end()

            return models.PreprocessResponse(info='preprocess complete')

        except KeyError as e:

            return models.PreprocessResponse(info=f"preprocess error: invalid token: {e}")

        except Exception as e:

            return models.PreprocessResponse(info=f"preprocess error: {e}")

        finally:

            shared.state.end()

    def train_embedding(self, args: dict):

        try:

            shared.state.begin(job="train_embedding")

class CreateResponse(BaseModel):

    info: str = Field(title="Create info", description="Response string from create embedding or hypernetwork task.")

class PreprocessResponse(BaseModel):

    info: str = Field(title="Preprocess info", description="Response string from preprocessing task.")

fields = {}

for key, metadata in opts.data_labels.items():

    value = opts.data.get(key)

parser.add_argument("--disable-opt-split-attention", action='store_true', help="prefer no cross-attention layer optimization for automatic choice of optimization")

parser.add_argument("--disable-nan-check", action='store_true', help="do not check if produced images/latent spaces have nans; useful for running without a checkpoint in CI")

parser.add_argument("--use-cpu", nargs='+', help="use CPU as torch device for specified modules", default=[], type=str.lower)

parser.add_argument("--use-ipex", action="store_true", help="use Intel XPU as torch device")

parser.add_argument("--disable-model-loading-ram-optimization", action='store_true', help="disable an optimization that reduces RAM use when loading a model")

parser.add_argument("--listen", action='store_true', help="launch gradio with 0.0.0.0 as server name, allowing to respond to network requests")

parser.add_argument("--port", type=int, help="launch gradio with given server port, you need root/admin rights for ports < 1024, defaults to 7860 if available", default=None)

if sys.platform == "darwin":

    from modules import mac_specific

if shared.cmd_opts.use_ipex:

    from modules import xpu_specific

def has_xpu() -> bool:

    return shared.cmd_opts.use_ipex and xpu_specific.has_xpu

def has_mps() -> bool:

    if sys.platform != "darwin":

    if has_mps():

        return "mps"

    if has_xpu():

        return xpu_specific.get_xpu_device_string()

    return "cpu"

    if has_mps():

        mac_specific.torch_mps_gc()

    if has_xpu():

        xpu_specific.torch_xpu_gc()

def enable_tf32():

    if torch.cuda.is_available():