Upload 16 files

app.py

@@ -1,6 +1,17 @@
 import spaces
 import gradio as gr
 from gradio_huggingfacehub_search import HuggingfaceHubSearch
+from t2i_config import KERNELS_PREFETCH_ON_STARTUP, KERNELS_PREFETCH_REPOS
+
+if KERNELS_PREFETCH_ON_STARTUP:
+    try:
+        from kernels import has_kernel, get_kernel
+        for _repo_id in KERNELS_PREFETCH_REPOS:
+            if has_kernel(_repo_id):
+                get_kernel(_repo_id)
+    except Exception as _e:
+        print(f"INFO : Kernels prefetch skipped: {_e}")
+
 from t2i.infer import (infer, infer_multi, infer_simple, save_image_history, save_gallery_history,
                        update_param_mode_gr, update_ar_gr,
                        MAX_SEED, MAX_IMAGE_SIZE, ASPECT_RATIOS, FILE_FORMATS, DEFAULT_TASKS, DEFAULT_DURATION,

t2i/infer.py

@@ -74,10 +74,13 @@ def infer_body(prompt: str, negative_prompt: str, seed: int, randomize_seed: boo
             kwargs, ikwargs = {"generator": generator}, {}
             metadata = {"prompt": prompt, "negative_prompt": negative_prompt, "Model": Path(model.split("/")[-1]).stem, "seed": seed}
             if negative_prompt: kwargs["negative_prompt"] = negative_prompt
+            if param_mode == "Auto":
+                params = get_auto_param(model_type)
+                kwargs |= params
+                metadata |= params
             elif param_mode != "Default":
-                params = get_auto_param(model_type) if param_mode == "Auto" else {}
-                kwargs |= {"guidance_scale": guidance_scale, "num_inference_steps": num_inference_steps, "width": width, "height": height} | params
-                metadata |= {"num_inference_steps": num_inference_steps, "guidance_scale": guidance_scale, "resolution": f"{width} x {height}"} | params
+                kwargs |= {"guidance_scale": guidance_scale, "num_inference_steps": num_inference_steps, "width": width, "height": height}
+                metadata |= {"num_inference_steps": num_inference_steps, "guidance_scale": guidance_scale, "resolution": f"{width} x {height}"}
 
             if task == TASK_T2I:
                 if pipe_type == "Long Prompt Weighting" and model_type == "SDXL": kwargs["clip_skip"], metadata["clip_skip"] = clip_skip, clip_skip

t2i/pipe.py

@@ -5,7 +5,7 @@ import torch
 from diffusers import DiffusionPipeline, AutoencoderKL
 from diffusers.models.attention_processor import AttnProcessor2_0
 from t2i_config import models, sdxl_vaes, sd15_vaes, PIPELINE_MAX_GIB
-from t2i.utils import (logger, get_token, free_memory, calc_pipe_size, is_weight_url, get_file,
+from t2i.utils import (logger, get_token, free_memory, calc_pipe_size, is_weight_url, get_file, apply_attention_backend,
                        get_model_type, get_model_type_from_pipe, get_task_class, DEFAULT_TASKS, IS_ZEROGPU, DEVICE, DTYPE, IS_QUANT,
                        MAX_SEED, MAX_IMAGE_SIZE, DEFAULT_MODEL_TYPE, DEFAULT_STR, ASPECT_RATIOS, PIPELINE_TYPES, DEFAULT_VAE, PARAM_MODES)
 
@@ -43,11 +43,7 @@ class Pipeline:
         self.lastmod = time.time()
         if device != "cpu" and not IS_QUANT:
             if self.pipe.device != device: self.pipe.to(device)
-            # https://huggingface.co/docs/diffusers/main/en/optimization/torch2.0
-            #if model_type in ["SD 1.5", "SDXL"]: self.pipe.unet.set_attn_processor(AttnProcessor2_0())
-            #elif model_type in ["FLUX"]: self.pipe.transformer.set_attn_processor(AttnProcessor2_0())
-            #self.pipe.vae.set_attn_processor(AttnProcessor2_0())
-            #logger.debug(f"SDPA enabled {type(self.pipe).__name__} ({model_type}) on {device}.") # by default in PyTorch 2.x
+            apply_attention_backend(self.pipe)
         return self.pipe
     
     def quantize(self):

t2i/utils.py

@@ -1,497 +1,598 @@
-import spaces
-import os, gc, json, uuid, time, datetime, re, urllib, tempfile, math, inspect
-from typing import Any, Tuple, Dict, List, Optional, Iterator
-from dataclasses import dataclass, field
-from pathlib import Path
-from PIL import Image, PngImagePlugin
-import torch
-import numpy as np
-import gradio as gr
-from huggingface_hub import HfApi, hf_hub_download
-from safetensors.torch import load_file
-from diffusers import (AutoPipelineForText2Image, AutoPipelineForImage2Image, AutoPipelineForInpainting, DiffusionPipeline,
-                       StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionControlNetInpaintPipeline,
-                       StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline, FluxPipeline, FluxImg2ImgPipeline, FluxInpaintPipeline, AutoencoderKL)
-from t2i.controlnet_union.pipeline.pipeline_controlnet_union_inpaint_sd_xl import StableDiffusionXLControlNetUnionInpaintPipeline
-from t2i_config import STORAGE_MAX_GIB, IS_DEBUG
-
-
-DEFAULT_STR = "Default"
-IS_ZEROGPU = True if os.getenv("SPACES_ZERO_GPU", None) else False
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-DTYPE = torch.bfloat16 if torch.cuda.is_available() else torch.float32
-IS_QUANT = False if IS_ZEROGPU else False # https://huggingface.co/posts/cbensimon/565026286160860#684a4147f1e1efa28f85ba5c
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 2048 #1216
-PIPELINE_TYPES = ["Default", "Long Prompt Weighting"]
-DEFAULT_VAE = DEFAULT_STR
-PARAM_MODES = ["Auto", "Default", "Custom"]
-DEFAULT_I2I_STRENGTH = 0.8
-DEFAULT_UPSCALE_STRENGTH = 0.55
-DEFAULT_UPSCALE_BY = 1.5
-DEFAULT_CLIP_SKIP = 2
-
-
-def get_logger():
-    import logging
-    from pytz import timezone
-    from datetime import datetime
-    logger = logging.getLogger(__name__)
-    if IS_DEBUG: logger.setLevel(logging.DEBUG)
-    else: logger.setLevel(logging.INFO)
-    sh = logging.StreamHandler()
-    sh.setLevel(logging.DEBUG if IS_DEBUG else logging.INFO)
-    def customTime(*args):
-        return datetime.now(timezone('Asia/Tokyo')).timetuple()
-    formatter = logging.Formatter(
-        fmt='%(levelname)s : %(asctime)s : %(message)s',
-        datefmt="%Y-%m-%d %H:%M:%S %z"
-    )
-    formatter.converter = customTime
-    sh.setFormatter(formatter)
-    logger.addHandler(sh)
-    return logger
-
-
-logger = get_logger()
-
-
-def get_token() -> Any:
-    return os.getenv("HF_TOKEN", None)
-
-
-def list_uniq_order(l: list) -> List:
-    return list(dict.fromkeys(l))
-
-
-def free_memory():
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-        #torch.cuda.ipc_collect()
-    gc.collect()
-
-
-def calc_module_size(model: torch.nn.Module) -> int:
-    param_size = 0
-    for param in model.parameters():
-        param_size += param.nelement() * param.element_size()
-    buffer_size = 0
-    for buffer in model.buffers():
-        buffer_size += buffer.nelement() * buffer.element_size()
-    return int(buffer_size + param_size)
-
-
-def calc_pipe_size(pipe: Any) -> int:
-    return sum([calc_module_size(m) for m in pipe.components.values() if isinstance(m, torch.nn.Module)])
-
-
-def calc_pix_8(x: float) -> int:
-    y = math.ceil(x)
-    return y - (y % 8)
-
-
-def calc_pix_64(x: float) -> int:
-    y = math.ceil(x)
-    return y - (y % 64)
-
-
-WEIGHT_EXTS = [".safetensors", ".sft", ".bin", ".pth"]
-
-
-def is_weight_url(url: str) -> bool:
-    if "http" not in url: return False
-    for ext in WEIGHT_EXTS:
-        if ext in url: return True
-    return False
-
-
-def read_safetensors_key(path: str) -> List[str]:
-    try:
-        keys = []
-        state_dict = load_file(str(Path(path)))
-        for k in list(state_dict.keys()):
-            keys.append(k)
-            state_dict.pop(k)
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-    finally:
-        del state_dict
-        free_memory()
-        return keys
-
-
-def split_hf_url(url: str) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str]]:
-    try:
-        s = list(re.findall(r'^(?:(?:https?://huggingface.co/)|(?:https?://hf.co/))(?:(datasets|spaces)/)?(.+?/.+?)/\w+?/.+?/(?:(.+)/)?(.+?.\w+)(?:\?download=true)?$', url)[0])
-        if len(s) < 4: return "", "", "", ""
-        repo_id = s[1]
-        if s[0] == "datasets": repo_type = "dataset"
-        elif s[0] == "spaces": repo_type = "space"
-        else: repo_type = "model"
-        subfolder = urllib.parse.unquote(s[2]) if s[2] else None
-        filename = urllib.parse.unquote(s[3])
-        return repo_id, filename, subfolder, repo_type
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-        return "", "", None, ""
-
-
-def download_hf_file(directory, url, progress=gr.Progress(track_tqdm=True)) -> Optional[str]:
-    hf_token = get_token()
-    repo_id, filename, subfolder, repo_type = split_hf_url(url)
-    if not repo_id:
-        logger.info(f"Failed to download {url}")
-        return None
-    try:
-        logger.debug(f"Downloading {url} to {directory}")
-        if subfolder is not None: path = hf_hub_download(repo_id=repo_id, filename=filename, subfolder=subfolder, repo_type=repo_type, local_dir=directory, token=hf_token)
-        else: path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type, local_dir=directory, token=hf_token)
-        return path
-    except Exception as e:
-        logger.info(f"Failed to download {e}")
-        return None
-
-
-@dataclass(order=True)
-class LocalFile:
-    path: str = ""
-    url: str = ""
-    lastmod: float = 0.
-    size: int = 0
-    keys: list = field(default_factory=list)
-
-    def __str__(self):
-        return f"{self.path} ({self.url}) Size:{float(self.size) / (1024.**3):.2f}GiB LastMod.:{datetime.datetime.fromtimestamp(self.lastmod).strftime('%Y/%m/%d %H:%M:%S')}"
-
-    def __del__(self):
-        delpath = Path(self.path)
-        if delpath.exists() and delpath.is_file(): delpath.unlink()
-        logger.debug(f"Deleted {self.path}.")
-
-
-class LocalFiles:
-    def __init__(self):
-        self.files: Dict[str, LocalFile] = {}
-        self.temp_dir = tempfile.mkdtemp()
-        self.max_gib = STORAGE_MAX_GIB
-    
-    def __call__(self, url: str) -> Optional[str]:
-        try:
-            if url in self.files.keys():
-                self.files[url].lastmod = time.time()
-                return self.files[url].path
-            path = download_hf_file(self.temp_dir, url)
-            if not path: return None
-            self.files[url] = LocalFile(path=path, url=url, lastmod=time.time(), size=os.path.getsize(Path(path)), keys=read_safetensors_key(path))
-            logger.info(f"Downloaded {self.files[url]}.")
-            self.clean()
-            return path
-        except Exception as e:
-            logger.debug(f"{inspect.currentframe().f_code.co_name}: {e}")
-            return None
-
-    def __str__(self):
-        return "\n".join([str(x) for x in self.files.values()])
-    
-    def clean(self):
-        items = sorted(list(self.files.values()), key=lambda x:x.lastmod, reverse=True)
-        sum_bytes = 0
-        max_bytes = self.max_gib * (1024 ** 3)
-        del_items = []
-        for item in items:
-            sum_bytes += item.size
-            if sum_bytes > max_bytes: del_items.append(item.name)
-        for item in del_items:
-            self.files.pop(item)
-
-    def get_keys(self, url: str) -> Optional[list[str]]:
-        if url not in self.files.keys(): self.__call__(url)
-        return self.files[url].keys if url in self.files.keys() else None
-
-
-local_files = LocalFiles()
-
-
-def get_file(url: str) -> Optional[str]:
-    path = local_files(url)
-    return path
-
-
-def get_file_keys(url: str) -> Optional[List[str]]:
-    return local_files.get_keys(url)
-
-
-MODEL_TYPE_CLASS = {
-    "diffusers:StableDiffusionPipeline": "SD 1.5",
-    "diffusers:StableDiffusionXLPipeline": "SDXL",
-    "diffusers:FluxPipeline": "FLUX",
-}
-
-
-PIPELINE_TO_TYPE = {k.replace("diffusers:", ""): v for k, v in MODEL_TYPE_CLASS.items()}
-MODEL_TYPE_VALUES = list(MODEL_TYPE_CLASS.values())
-DEFAULT_MODEL_TYPE = "Auto"
-MODEL_TYPES = [DEFAULT_MODEL_TYPE] + MODEL_TYPE_VALUES
-
-
-def get_model_type_from_repo_id(repo_id: str) -> str:
-    api = HfApi(token=get_token())
-    default = "SDXL"
-    try:
-        model = api.model_info(repo_id=repo_id, timeout=5.0)
-        tags = model.tags
-        for tag in tags:
-            if tag in MODEL_TYPE_CLASS.keys(): return MODEL_TYPE_CLASS.get(tag, default)
-    except Exception:
-        return default
-    return default
-
-
-MODEL_TYPE_KEY = {
-    "model.diffusion_model.output_blocks.1.1.norm.bias": "SDXL",
-    "model.diffusion_model.input_blocks.11.0.out_layers.3.weight": "SD 1.5",
-    "double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
-    "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
-    "model.diffusion_model.joint_blocks.9.x_block.attn.ln_k.weight": "SD 3.5",
-}
-
-
-def get_model_type_from_key(url: str) -> str:
-    default = "SDXL"
-    try:
-        keys = get_file_keys(url)
-        for k, v in MODEL_TYPE_KEY.items():
-            if k in set(keys): return v
-    except Exception:
-        return default
-    return default
-
-
-def get_model_type_from_url(url: str) -> str:
-    default = "SDXL"
-    try:
-        return get_model_type_from_key(url)
-    except Exception:
-        return default
-
-
-def get_model_type(name: str) -> str:
-    model_type = DEFAULT_MODEL_TYPE
-    try:
-        if is_weight_url(name): model_type = get_model_type_from_url(name)
-        else: model_type = get_model_type_from_repo_id(name)
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-    finally:
-        logger.debug(f"{name} is determined as {model_type}.")
-        return model_type
-
-
-def get_model_type_from_pipe(pipe: Any) -> str:
-    model_type = PIPELINE_TO_TYPE.get(type(pipe).__name__, DEFAULT_MODEL_TYPE)
-    logger.debug(f"{type(pipe).__name__} is determined as {model_type}.")
-    return model_type
-
-
-AR_TO_REZ = {
-    "1:1 (Square)": "1024x1024",
-    "3:2 (Landscape)": "1216x832",
-    "2:3 (Portrait)": "832x1216",
-    "16:9 (HD TV)": "1344x768",
-    "9:16 (Selfie)": "768x1344",
-    "4:3 (SD TV)": "1152x896",
-    "3:4 (Standard)": "896x1152",
-    "21:9 (Cinema)": "1536x640",
-    "9:21": "640x1536",
-    "3:1": "1728x576",
-    "1:3": "576x1728",
-    "4:1": "2048x512",
-    "1:4": "512x2048"
-}
-SDXL_REZ = [s for s in AR_TO_REZ.values()]
-AR_CUSTOM = "Custom"
-ASPECT_RATIOS = [AR_CUSTOM] + [s for s in AR_TO_REZ.keys()]
-MODEL_TYPE_REZ = {"SDXL": 1024, "SD 1.5": 512, "FLUX": 1024}
-
-
-def get_rez_from_ar(ar: str, type: str="SDXL", sw: int=1024, sh: int=1024) -> Tuple[int, int]:
-    if ar == AR_CUSTOM: return sw, sh
-    br = AR_TO_REZ.get(ar, SDXL_REZ[0])
-    bw, bh = int(br.split("x")[0]), int(br.split("x")[1])
-    sr = 1024 # SDXL
-    tr = MODEL_TYPE_REZ.get(type, 1024)
-    return calc_pix_64(bw * tr / sr), calc_pix_64(bh * tr / sr)
-
-
-def update_ar_gr(ar: str):
-    if ar == AR_CUSTOM: return gr.update(visible=True), gr.update(visible=True)
-    else: return gr.update(visible=False), gr.update(visible=False)
-
-
-AUTO_PARAM_DICT = {
-    "SD 1.5": {"guidance_scale": 7., "num_inference_steps": 50},
-    "SDXL": {"guidance_scale": 7., "num_inference_steps": 28},
-    "FLUX": {"guidance_scale": 3.5, "num_inference_steps": 28},
-}
-
-
-def get_auto_param(type: str) -> Dict:
-    param = AUTO_PARAM_DICT.get(type, {})
-    return param
-
-
-def update_param_mode_gr(mode: str):
-    if mode in ["Auto", "Default"]: return gr.update(visible=False), gr.update(visible=False)
-    else: return gr.update(visible=True), gr.update(visible=True)
-
-
-TASK_T2I = "Text-to-Image"
-TASK_I2I = "Image-to-Image"
-TASK_INPAINT = "Inpaint"
-DEFAULT_PIPE_CLASS = "Auto"
-
-
-DIFFUSERS_TASK = {
-    DEFAULT_PIPE_CLASS: {
-        TASK_T2I: AutoPipelineForText2Image,
-        TASK_I2I: AutoPipelineForImage2Image,
-        TASK_INPAINT: AutoPipelineForInpainting,
-    },
-    "SD 1.5": {
-        TASK_T2I: StableDiffusionPipeline,
-        TASK_I2I: StableDiffusionImg2ImgPipeline,
-        TASK_INPAINT: StableDiffusionControlNetInpaintPipeline,
-    },
-    "SDXL": {
-        TASK_T2I: StableDiffusionXLPipeline,
-        TASK_I2I: StableDiffusionXLImg2ImgPipeline,
-        TASK_INPAINT: StableDiffusionXLControlNetUnionInpaintPipeline,
-    },
-    "FLUX": {
-        TASK_T2I: FluxPipeline,
-        TASK_I2I: FluxImg2ImgPipeline,
-        TASK_INPAINT: FluxInpaintPipeline,
-    },
-}
-
-
-def get_tasks(model_type: str=DEFAULT_PIPE_CLASS) -> List[str]:
-    if model_type not in DIFFUSERS_TASK.keys(): model_type = DEFAULT_PIPE_CLASS
-    return [x for x in DIFFUSERS_TASK.get(model_type, DEFAULT_PIPE_CLASS).keys()]
-
-
-def get_task_class(model_type: str, task: str) -> Any:
-    if model_type not in DIFFUSERS_TASK.keys(): model_type = DEFAULT_PIPE_CLASS
-    try:
-        return DIFFUSERS_TASK[model_type][task]
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-        return DIFFUSERS_TASK[DEFAULT_PIPE_CLASS][task]
-
-
-DEFAULT_TASKS = get_tasks()
-KNOWN_PIPE_CLASS = [x for x in DIFFUSERS_TASK.keys() if x != DEFAULT_PIPE_CLASS]
-
-
-HF_DEFAULT_STEPS = 50
-DEFAULT_INFER_TIME = 10.
-MODEL_INFER_TIME = {"SD 1.5": 5.0, "SDXL": 8.5}
-
-
-def get_final_steps(type: str, mode: str, steps: int) -> int:
-    if mode not in ["Default", "Auto"]: return steps
-    if mode == "Auto":
-        param = get_auto_param(type)
-        s = param.get("num_inference_steps", None)
-        if s is None: return HF_DEFAULT_STEPS
-        else: return s
-    elif mode == "Default": return HF_DEFAULT_STEPS
-    return steps
-
-
-def estimate_model_infer_time(type: str=DEFAULT_MODEL_TYPE, task: str=DEFAULT_TASKS[0], mode: str=PARAM_MODES[0], steps: int=HF_DEFAULT_STEPS) -> float:
-    steps = get_final_steps(type, mode, steps)
-    base_time = MODEL_INFER_TIME.get(type, DEFAULT_INFER_TIME)
-    time = (base_time * 0.25) + (base_time * 0.75 * float(steps) / float(HF_DEFAULT_STEPS))
-    if task == TASK_INPAINT: time *= 3. if type == "SD 1.5" else 1.5
-    elif task == TASK_I2I: time *= 1.5
-    return time
-
-
-def resize_ref_image(image: Image.Image) -> Image.Image:
-    MIN_SIZE = 256
-    try:
-        ow, oh = image.size
-        if ow > oh:
-            tw = max(calc_pix_8(ow), MIN_SIZE)
-            th = calc_pix_8(tw * oh / ow)
-        else:
-            th = max(calc_pix_8(oh), MIN_SIZE)
-            tw = calc_pix_8(th * ow / oh)
-        return image.resize((tw, th), Image.LANCZOS)
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-        return image
-
-
-def get_image_mask(image_dict: Optional[Dict]) -> Tuple[Optional[Image.Image], Optional[Image.Image]]:
-    image, mask = None, None
-    try:
-        if isinstance(image_dict, dict):
-            image = image_dict.get("background", None)
-            layers = image_dict.get("layers", None)
-            mask = layers[0] if layers is not None and len(layers) > 0 else None
-            if isinstance(image, str): image = Image.open(image)
-            if isinstance(image, Image.Image): image = resize_ref_image(image).convert("RGB")
-            if isinstance(mask, str): mask = Image.open(mask)
-            if isinstance(mask, Image.Image): mask = resize_ref_image(mask).convert("L")
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-    finally:
-        logger.debug(f"Image:{image}, Mask:{mask}")
-        return image, mask
-
-
-FILE_FORMAT_MAP = {"PNG": "png", "WebP": "webp", "JPEG": "jpg"}
-FILE_FORMATS = [x for x in FILE_FORMAT_MAP.keys()]
-
-
-def save_image(image: Image.Image, metadata: dict, format: str=FILE_FORMATS[0]) -> Optional[str]:
-    try:
-        ext = FILE_FORMAT_MAP.get(format, "png")
-        savefile = f'{metadata["Model"]}_{str(uuid.uuid4())}.{ext}'
-        if ext in ["png"]:
-            metadata_str = json.dumps(metadata)
-            info = PngImagePlugin.PngInfo()
-            info.add_text("metadata", metadata_str)
-            image.save(savefile, "PNG", pnginfo=info)
-        else: image.save(savefile)
-        return str(Path(savefile).resolve())
-    except Exception as e:
-        logger.info(f"Failed to save image file: {e}")
-        raise Exception(f"Failed to save image file: {e}") from e
-
-
-def save_image_history(image: str, gallery: Optional[List], files: Optional[List], progress=gr.Progress(track_tqdm=True)):
-    if not gallery: gallery = []
-    if not files: files = []
-    try:
-        if isinstance(image, str):
-            files.insert(0, str(Path(image).resolve()))
-            gallery.insert(0, (str(Path(image).resolve()), str(Path(image).name)))
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-    finally: 
-        return gr.update(value=gallery), gr.update(value=files, visible=True)
-
-
-def save_gallery_history(images: Optional[List], gallery: Optional[List], files: Optional[List], progress=gr.Progress(track_tqdm=True)):
-    if not gallery: gallery = []
-    if not files: files = []
-    try:
-        gallery = list_uniq_order(images.copy() + gallery)
-        files = [x[0] for x in gallery]
-    except Exception as e:
-        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
-    finally: 
-        return gr.update(value=gallery), gr.update(value=files, visible=True)
+import spaces
+import os, gc, json, uuid, time, datetime, re, urllib, tempfile, math, inspect
+from typing import Any, Tuple, Dict, List, Optional, Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+from PIL import Image, PngImagePlugin
+import torch
+import numpy as np
+import gradio as gr
+from huggingface_hub import HfApi, hf_hub_download
+from safetensors.torch import load_file
+from diffusers import (AutoPipelineForText2Image, AutoPipelineForImage2Image, AutoPipelineForInpainting, DiffusionPipeline,
+                       StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionControlNetInpaintPipeline,
+                       StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline, FluxPipeline, FluxImg2ImgPipeline, FluxInpaintPipeline, AutoencoderKL)
+from t2i.controlnet_union.pipeline.pipeline_controlnet_union_inpaint_sd_xl import StableDiffusionXLControlNetUnionInpaintPipeline
+from t2i_config import STORAGE_MAX_GIB, IS_DEBUG, ATTENTION_BACKEND, ATTENTION_BACKEND_NON_HOPPER
+
+
+DEFAULT_STR = "Default"
+IS_ZEROGPU = True if os.getenv("SPACES_ZERO_GPU", None) else False
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DTYPE = torch.bfloat16 if torch.cuda.is_available() else torch.float32
+IS_QUANT = False if IS_ZEROGPU else False # https://huggingface.co/posts/cbensimon/565026286160860#684a4147f1e1efa28f85ba5c
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 2048 #1216
+PIPELINE_TYPES = ["Default", "Long Prompt Weighting"]
+DEFAULT_VAE = DEFAULT_STR
+PARAM_MODES = ["Auto", "Default", "Custom"]
+DEFAULT_I2I_STRENGTH = 0.8
+DEFAULT_UPSCALE_STRENGTH = 0.55
+DEFAULT_UPSCALE_BY = 1.5
+DEFAULT_CLIP_SKIP = 2
+
+# Attention backend switching (Diffusers attention dispatcher)
+# Works across SD1.5/SDXL/FLUX by applying to any component that supports set_attention_backend().
+# Config lives in t2i_config.py (ATTENTION_BACKEND, ATTENTION_BACKEND_NON_HOPPER).
+def _is_hopper_gpu() -> bool:
+    if not torch.cuda.is_available():
+        return False
+    try:
+        major, minor = torch.cuda.get_device_capability()
+        return major >= 9  # SM90+ (Hopper)
+    except Exception:
+        return False
+
+
+def _resolve_attention_backend() -> Optional[str]:
+    backend = ATTENTION_BACKEND
+    if backend is None:
+        return None
+    backend = str(backend).strip()
+    if backend == "":
+        return None
+    if backend.lower() == "auto":
+        return "_flash_3_hub" if _is_hopper_gpu() else (ATTENTION_BACKEND_NON_HOPPER or "flash_hub")
+    return backend
+
+
+def _iter_attention_targets(pipe: Any) -> Iterator[Any]:
+    # common attributes
+    for name in ["unet", "transformer", "controlnet"]:
+        if hasattr(pipe, name):
+            obj = getattr(pipe, name)
+            if obj is None:
+                continue
+            if isinstance(obj, (list, tuple, set)):
+                for o in obj:
+                    if o is not None:
+                        yield o
+            elif isinstance(obj, dict):
+                for o in obj.values():
+                    if o is not None:
+                        yield o
+            else:
+                yield obj
+
+    # pipeline.components (dict)
+    if hasattr(pipe, "components"):
+        try:
+            comps = getattr(pipe, "components")
+            if isinstance(comps, dict):
+                for o in comps.values():
+                    if o is None:
+                        continue
+                    if isinstance(o, (list, tuple, set)):
+                        for x in o:
+                            if x is not None:
+                                yield x
+                    elif isinstance(o, dict):
+                        for x in o.values():
+                            if x is not None:
+                                yield x
+                    else:
+                        yield o
+        except Exception:
+            pass
+
+
+def apply_attention_backend(pipe: Any) -> bool:
+    backend = _resolve_attention_backend()
+    if not backend:
+        return False
+
+    prev = getattr(pipe, "_t2i_attention_backend", None)
+    if prev == backend:
+        return False
+
+    applied: List[str] = []
+    seen = set()
+
+    for obj in _iter_attention_targets(pipe):
+        oid = id(obj)
+        if oid in seen:
+            continue
+        seen.add(oid)
+
+        if not hasattr(obj, "set_attention_backend"):
+            continue
+
+        try:
+            obj.set_attention_backend(backend)
+            applied.append(type(obj).__name__)
+        except Exception as e:
+            logger.debug(f"set_attention_backend({backend}) failed on {type(obj).__name__}: {e}")
+
+    if applied:
+        pipe._t2i_attention_backend = backend
+        logger.debug(f"Attention backend set to {backend} on {list_uniq_order(applied)}.")
+        return True
+
+    logger.debug(f"Attention backend {backend} was not applied (no compatible components).")
+    pipe._t2i_attention_backend = None
+    return False
+
+
+def get_logger():
+    import logging
+    from pytz import timezone
+    from datetime import datetime
+    logger = logging.getLogger(__name__)
+    if IS_DEBUG: logger.setLevel(logging.DEBUG)
+    else: logger.setLevel(logging.INFO)
+    sh = logging.StreamHandler()
+    sh.setLevel(logging.DEBUG if IS_DEBUG else logging.INFO)
+    def customTime(*args):
+        return datetime.now(timezone('Asia/Tokyo')).timetuple()
+    formatter = logging.Formatter(
+        fmt='%(levelname)s : %(asctime)s : %(message)s',
+        datefmt="%Y-%m-%d %H:%M:%S %z"
+    )
+    formatter.converter = customTime
+    sh.setFormatter(formatter)
+    logger.addHandler(sh)
+    return logger
+
+
+logger = get_logger()
+
+
+def get_token() -> Any:
+    return os.getenv("HF_TOKEN", None)
+
+
+def list_uniq_order(l: list) -> List:
+    return list(dict.fromkeys(l))
+
+
+def free_memory():
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        #torch.cuda.ipc_collect()
+    gc.collect()
+
+
+def calc_module_size(model: torch.nn.Module) -> int:
+    param_size = 0
+    for param in model.parameters():
+        param_size += param.nelement() * param.element_size()
+    buffer_size = 0
+    for buffer in model.buffers():
+        buffer_size += buffer.nelement() * buffer.element_size()
+    return int(buffer_size + param_size)
+
+
+def calc_pipe_size(pipe: Any) -> int:
+    return sum([calc_module_size(m) for m in pipe.components.values() if isinstance(m, torch.nn.Module)])
+
+
+def calc_pix_8(x: float) -> int:
+    y = math.ceil(x)
+    return y - (y % 8)
+
+
+def calc_pix_64(x: float) -> int:
+    y = math.ceil(x)
+    return y - (y % 64)
+
+
+WEIGHT_EXTS = [".safetensors", ".sft", ".bin", ".pth"]
+
+
+def is_weight_url(url: str) -> bool:
+    if "http" not in url: return False
+    for ext in WEIGHT_EXTS:
+        if ext in url: return True
+    return False
+
+
+def read_safetensors_key(path: str) -> List[str]:
+    try:
+        keys = []
+        state_dict = load_file(str(Path(path)))
+        for k in list(state_dict.keys()):
+            keys.append(k)
+            state_dict.pop(k)
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+    finally:
+        del state_dict
+        free_memory()
+        return keys
+
+
+def split_hf_url(url: str) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str]]:
+    try:
+        s = list(re.findall(r'^(?:(?:https?://huggingface.co/)|(?:https?://hf.co/))(?:(datasets|spaces)/)?(.+?/.+?)/\w+?/.+?/(?:(.+)/)?(.+?.\w+)(?:\?download=true)?$', url)[0])
+        if len(s) < 4: return "", "", "", ""
+        repo_id = s[1]
+        if s[0] == "datasets": repo_type = "dataset"
+        elif s[0] == "spaces": repo_type = "space"
+        else: repo_type = "model"
+        subfolder = urllib.parse.unquote(s[2]) if s[2] else None
+        filename = urllib.parse.unquote(s[3])
+        return repo_id, filename, subfolder, repo_type
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+        return "", "", None, ""
+
+
+def download_hf_file(directory, url, progress=gr.Progress(track_tqdm=True)) -> Optional[str]:
+    hf_token = get_token()
+    repo_id, filename, subfolder, repo_type = split_hf_url(url)
+    if not repo_id:
+        logger.info(f"Failed to download {url}")
+        return None
+    try:
+        logger.debug(f"Downloading {url} to {directory}")
+        if subfolder is not None: path = hf_hub_download(repo_id=repo_id, filename=filename, subfolder=subfolder, repo_type=repo_type, local_dir=directory, token=hf_token)
+        else: path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type, local_dir=directory, token=hf_token)
+        return path
+    except Exception as e:
+        logger.info(f"Failed to download {e}")
+        return None
+
+
+@dataclass(order=True)
+class LocalFile:
+    path: str = ""
+    url: str = ""
+    lastmod: float = 0.
+    size: int = 0
+    keys: list = field(default_factory=list)
+
+    def __str__(self):
+        return f"{self.path} ({self.url}) Size:{float(self.size) / (1024.**3):.2f}GiB LastMod.:{datetime.datetime.fromtimestamp(self.lastmod).strftime('%Y/%m/%d %H:%M:%S')}"
+
+    def __del__(self):
+        delpath = Path(self.path)
+        if delpath.exists() and delpath.is_file(): delpath.unlink()
+        logger.debug(f"Deleted {self.path}.")
+
+
+class LocalFiles:
+    def __init__(self):
+        self.files: Dict[str, LocalFile] = {}
+        self.temp_dir = tempfile.mkdtemp()
+        self.max_gib = STORAGE_MAX_GIB
+    
+    def __call__(self, url: str) -> Optional[str]:
+        try:
+            if url in self.files.keys():
+                self.files[url].lastmod = time.time()
+                return self.files[url].path
+            path = download_hf_file(self.temp_dir, url)
+            if not path: return None
+            self.files[url] = LocalFile(path=path, url=url, lastmod=time.time(), size=os.path.getsize(Path(path)), keys=read_safetensors_key(path))
+            logger.info(f"Downloaded {self.files[url]}.")
+            self.clean()
+            return path
+        except Exception as e:
+            logger.debug(f"{inspect.currentframe().f_code.co_name}: {e}")
+            return None
+
+    def __str__(self):
+        return "\n".join([str(x) for x in self.files.values()])
+    
+    def clean(self):
+        items = sorted(list(self.files.values()), key=lambda x:x.lastmod, reverse=True)
+        sum_bytes = 0
+        max_bytes = self.max_gib * (1024 ** 3)
+        del_items = []
+        for item in items:
+            sum_bytes += item.size
+            if sum_bytes > max_bytes: del_items.append(item.name)
+        for item in del_items:
+            self.files.pop(item)
+
+    def get_keys(self, url: str) -> Optional[list[str]]:
+        if url not in self.files.keys(): self.__call__(url)
+        return self.files[url].keys if url in self.files.keys() else None
+
+
+local_files = LocalFiles()
+
+
+def get_file(url: str) -> Optional[str]:
+    path = local_files(url)
+    return path
+
+
+def get_file_keys(url: str) -> Optional[List[str]]:
+    return local_files.get_keys(url)
+
+
+MODEL_TYPE_CLASS = {
+    "diffusers:StableDiffusionPipeline": "SD 1.5",
+    "diffusers:StableDiffusionXLPipeline": "SDXL",
+    "diffusers:FluxPipeline": "FLUX",
+}
+
+
+PIPELINE_TO_TYPE = {k.replace("diffusers:", ""): v for k, v in MODEL_TYPE_CLASS.items()}
+MODEL_TYPE_VALUES = list(MODEL_TYPE_CLASS.values())
+DEFAULT_MODEL_TYPE = "Auto"
+MODEL_TYPES = [DEFAULT_MODEL_TYPE] + MODEL_TYPE_VALUES
+
+
+def get_model_type_from_repo_id(repo_id: str) -> str:
+    api = HfApi(token=get_token())
+    default = "SDXL"
+    try:
+        model = api.model_info(repo_id=repo_id, timeout=5.0)
+        tags = model.tags
+        for tag in tags:
+            if tag in MODEL_TYPE_CLASS.keys(): return MODEL_TYPE_CLASS.get(tag, default)
+    except Exception:
+        return default
+    return default
+
+
+MODEL_TYPE_KEY = {
+    "model.diffusion_model.output_blocks.1.1.norm.bias": "SDXL",
+    "model.diffusion_model.input_blocks.11.0.out_layers.3.weight": "SD 1.5",
+    "double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
+    "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale": "FLUX",
+    "model.diffusion_model.joint_blocks.9.x_block.attn.ln_k.weight": "SD 3.5",
+}
+
+
+def get_model_type_from_key(url: str) -> str:
+    default = "SDXL"
+    try:
+        keys = get_file_keys(url)
+        for k, v in MODEL_TYPE_KEY.items():
+            if k in set(keys): return v
+    except Exception:
+        return default
+    return default
+
+
+def get_model_type_from_url(url: str) -> str:
+    default = "SDXL"
+    try:
+        return get_model_type_from_key(url)
+    except Exception:
+        return default
+
+
+def get_model_type(name: str) -> str:
+    model_type = DEFAULT_MODEL_TYPE
+    try:
+        if is_weight_url(name): model_type = get_model_type_from_url(name)
+        else: model_type = get_model_type_from_repo_id(name)
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+    finally:
+        logger.debug(f"{name} is determined as {model_type}.")
+        return model_type
+
+
+def get_model_type_from_pipe(pipe: Any) -> str:
+    model_type = PIPELINE_TO_TYPE.get(type(pipe).__name__, DEFAULT_MODEL_TYPE)
+    logger.debug(f"{type(pipe).__name__} is determined as {model_type}.")
+    return model_type
+
+
+AR_TO_REZ = {
+    "1:1 (Square)": "1024x1024",
+    "3:2 (Landscape)": "1216x832",
+    "2:3 (Portrait)": "832x1216",
+    "16:9 (HD TV)": "1344x768",
+    "9:16 (Selfie)": "768x1344",
+    "4:3 (SD TV)": "1152x896",
+    "3:4 (Standard)": "896x1152",
+    "21:9 (Cinema)": "1536x640",
+    "9:21": "640x1536",
+    "3:1": "1728x576",
+    "1:3": "576x1728",
+    "4:1": "2048x512",
+    "1:4": "512x2048"
+}
+SDXL_REZ = [s for s in AR_TO_REZ.values()]
+AR_CUSTOM = "Custom"
+ASPECT_RATIOS = [AR_CUSTOM] + [s for s in AR_TO_REZ.keys()]
+MODEL_TYPE_REZ = {"SDXL": 1024, "SD 1.5": 512, "FLUX": 1024}
+
+
+def get_rez_from_ar(ar: str, type: str="SDXL", sw: int=1024, sh: int=1024) -> Tuple[int, int]:
+    if ar == AR_CUSTOM: return sw, sh
+    br = AR_TO_REZ.get(ar, SDXL_REZ[0])
+    bw, bh = int(br.split("x")[0]), int(br.split("x")[1])
+    sr = 1024 # SDXL
+    tr = MODEL_TYPE_REZ.get(type, 1024)
+    return calc_pix_64(bw * tr / sr), calc_pix_64(bh * tr / sr)
+
+
+def update_ar_gr(ar: str):
+    if ar == AR_CUSTOM: return gr.update(visible=True), gr.update(visible=True)
+    else: return gr.update(visible=False), gr.update(visible=False)
+
+
+AUTO_PARAM_DICT = {
+    "SD 1.5": {"guidance_scale": 7., "num_inference_steps": 50},
+    "SDXL": {"guidance_scale": 7., "num_inference_steps": 28},
+    "FLUX": {"guidance_scale": 3.5, "num_inference_steps": 28},
+}
+
+
+def get_auto_param(type: str) -> Dict:
+    param = AUTO_PARAM_DICT.get(type, {})
+    return param
+
+
+def update_param_mode_gr(mode: str):
+    if mode in ["Auto", "Default"]: return gr.update(visible=False), gr.update(visible=False)
+    else: return gr.update(visible=True), gr.update(visible=True)
+
+
+TASK_T2I = "Text-to-Image"
+TASK_I2I = "Image-to-Image"
+TASK_INPAINT = "Inpaint"
+DEFAULT_PIPE_CLASS = "Auto"
+
+
+DIFFUSERS_TASK = {
+    DEFAULT_PIPE_CLASS: {
+        TASK_T2I: AutoPipelineForText2Image,
+        TASK_I2I: AutoPipelineForImage2Image,
+        TASK_INPAINT: AutoPipelineForInpainting,
+    },
+    "SD 1.5": {
+        TASK_T2I: StableDiffusionPipeline,
+        TASK_I2I: StableDiffusionImg2ImgPipeline,
+        TASK_INPAINT: StableDiffusionControlNetInpaintPipeline,
+    },
+    "SDXL": {
+        TASK_T2I: StableDiffusionXLPipeline,
+        TASK_I2I: StableDiffusionXLImg2ImgPipeline,
+        TASK_INPAINT: StableDiffusionXLControlNetUnionInpaintPipeline,
+    },
+    "FLUX": {
+        TASK_T2I: FluxPipeline,
+        TASK_I2I: FluxImg2ImgPipeline,
+        TASK_INPAINT: FluxInpaintPipeline,
+    },
+}
+
+
+def get_tasks(model_type: str=DEFAULT_PIPE_CLASS) -> List[str]:
+    if model_type not in DIFFUSERS_TASK.keys(): model_type = DEFAULT_PIPE_CLASS
+    return [x for x in DIFFUSERS_TASK.get(model_type, DEFAULT_PIPE_CLASS).keys()]
+
+
+def get_task_class(model_type: str, task: str) -> Any:
+    if model_type not in DIFFUSERS_TASK.keys(): model_type = DEFAULT_PIPE_CLASS
+    try:
+        return DIFFUSERS_TASK[model_type][task]
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+        return DIFFUSERS_TASK[DEFAULT_PIPE_CLASS][task]
+
+
+DEFAULT_TASKS = get_tasks()
+KNOWN_PIPE_CLASS = [x for x in DIFFUSERS_TASK.keys() if x != DEFAULT_PIPE_CLASS]
+
+
+HF_DEFAULT_STEPS = 50
+DEFAULT_INFER_TIME = 10.
+MODEL_INFER_TIME = {"SD 1.5": 5.0, "SDXL": 8.5}
+
+
+def get_final_steps(type: str, mode: str, steps: int) -> int:
+    if mode not in ["Default", "Auto"]: return steps
+    if mode == "Auto":
+        param = get_auto_param(type)
+        s = param.get("num_inference_steps", None)
+        if s is None: return HF_DEFAULT_STEPS
+        else: return s
+    elif mode == "Default": return HF_DEFAULT_STEPS
+    return steps
+
+
+def estimate_model_infer_time(type: str=DEFAULT_MODEL_TYPE, task: str=DEFAULT_TASKS[0], mode: str=PARAM_MODES[0], steps: int=HF_DEFAULT_STEPS) -> float:
+    steps = get_final_steps(type, mode, steps)
+    base_time = MODEL_INFER_TIME.get(type, DEFAULT_INFER_TIME)
+    time = (base_time * 0.25) + (base_time * 0.75 * float(steps) / float(HF_DEFAULT_STEPS))
+    if task == TASK_INPAINT: time *= 3. if type == "SD 1.5" else 1.5
+    elif task == TASK_I2I: time *= 1.5
+    return time
+
+
+def resize_ref_image(image: Image.Image) -> Image.Image:
+    MIN_SIZE = 256
+    try:
+        ow, oh = image.size
+        if ow > oh:
+            tw = max(calc_pix_8(ow), MIN_SIZE)
+            th = calc_pix_8(tw * oh / ow)
+        else:
+            th = max(calc_pix_8(oh), MIN_SIZE)
+            tw = calc_pix_8(th * ow / oh)
+        return image.resize((tw, th), Image.LANCZOS)
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+        return image
+
+
+def get_image_mask(image_dict: Optional[Dict]) -> Tuple[Optional[Image.Image], Optional[Image.Image]]:
+    image, mask = None, None
+    try:
+        if isinstance(image_dict, dict):
+            image = image_dict.get("background", None)
+            layers = image_dict.get("layers", None)
+            mask = layers[0] if layers is not None and len(layers) > 0 else None
+            if isinstance(image, str): image = Image.open(image)
+            if isinstance(image, Image.Image): image = resize_ref_image(image).convert("RGB")
+            if isinstance(mask, str): mask = Image.open(mask)
+            if isinstance(mask, Image.Image): mask = resize_ref_image(mask).convert("L")
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+    finally:
+        logger.debug(f"Image:{image}, Mask:{mask}")
+        return image, mask
+
+
+FILE_FORMAT_MAP = {"PNG": "png", "WebP": "webp", "JPEG": "jpg"}
+FILE_FORMATS = [x for x in FILE_FORMAT_MAP.keys()]
+
+
+def save_image(image: Image.Image, metadata: dict, format: str=FILE_FORMATS[0]) -> Optional[str]:
+    try:
+        ext = FILE_FORMAT_MAP.get(format, "png")
+        savefile = f'{metadata["Model"]}_{str(uuid.uuid4())}.{ext}'
+        if ext in ["png"]:
+            metadata_str = json.dumps(metadata)
+            info = PngImagePlugin.PngInfo()
+            info.add_text("metadata", metadata_str)
+            image.save(savefile, "PNG", pnginfo=info)
+        else: image.save(savefile)
+        return str(Path(savefile).resolve())
+    except Exception as e:
+        logger.info(f"Failed to save image file: {e}")
+        raise Exception(f"Failed to save image file: {e}") from e
+
+
+def save_image_history(image: str, gallery: Optional[List], files: Optional[List], progress=gr.Progress(track_tqdm=True)):
+    if not gallery: gallery = []
+    if not files: files = []
+    try:
+        if isinstance(image, str):
+            files.insert(0, str(Path(image).resolve()))
+            gallery.insert(0, (str(Path(image).resolve()), str(Path(image).name)))
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+    finally: 
+        return gr.update(value=gallery), gr.update(value=files, visible=True)
+
+
+def save_gallery_history(images: Optional[List], gallery: Optional[List], files: Optional[List], progress=gr.Progress(track_tqdm=True)):
+    if not gallery: gallery = []
+    if not files: files = []
+    try:
+        gallery = list_uniq_order(images.copy() + gallery)
+        files = [x[0] for x in gallery]
+    except Exception as e:
+        logger.info(f"{inspect.currentframe().f_code.co_name}: {e}")
+    finally: 
+        return gr.update(value=gallery), gr.update(value=files, visible=True)

t2i_config.py

@@ -1,30 +1,47 @@
-
-models = [
-    'Yntec/YiffyMix',
-    'Raelina/Rae-Diffusion-XL-V2',
-    'Raelina/Raemu-XL-V4',
-    'Raelina/Raemu-XL-V5',
-    'Raelina/Raena-XL-V2',
-    'Raelina/Raehoshi-illust-XL',
-    'Raelina/Raehoshi-illust-xl-2',
-    'Raelina/Raehoshi-Illust-XL-2.1',
-    'Raelina/Raehoshi-illust-XL-3',
-    'Raelina/Raehoshi-illust-XL-4',
-    'Raelina/Raehoshi-illust-XL-8',
-    "https://huggingface.co/Yntec/epiCPhotoGasm/blob/main/epiCPhotoGasmVAE.safetensors",
-]
-
-
-sdxl_vaes = [
-    "madebyollin/sdxl-vae-fp16-fix",
-    "https://huggingface.co/nubby/blessed-sdxl-vae-fp16-fix/blob/main/sdxl_vae-fp16fix-blessed.safetensors",
-]
-
-
-sd15_vaes = []
-
-
-STORAGE_MAX_GIB = 40
-PIPELINE_MAX_GIB = 30
-DEFAULT_DURATION = 0 # if 0, auto
-IS_DEBUG = True
+
+models = [
+    'Yntec/YiffyMix',
+    'Raelina/Rae-Diffusion-XL-V2',
+    'Raelina/Raemu-XL-V4',
+    'Raelina/Raemu-XL-V5',
+    'Raelina/Raena-XL-V2',
+    'Raelina/Raehoshi-illust-XL',
+    'Raelina/Raehoshi-illust-xl-2',
+    'Raelina/Raehoshi-Illust-XL-2.1',
+    'Raelina/Raehoshi-illust-XL-3',
+    'Raelina/Raehoshi-illust-XL-4',
+    'Raelina/Raehoshi-illust-XL-8',
+    "https://huggingface.co/Yntec/epiCPhotoGasm/blob/main/epiCPhotoGasmVAE.safetensors",
+]
+
+
+sdxl_vaes = [
+    "madebyollin/sdxl-vae-fp16-fix",
+    "https://huggingface.co/nubby/blessed-sdxl-vae-fp16-fix/blob/main/sdxl_vae-fp16fix-blessed.safetensors",
+]
+
+
+sd15_vaes = []
+
+
+STORAGE_MAX_GIB = 40
+PIPELINE_MAX_GIB = 30
+DEFAULT_DURATION = 0 # if 0, auto
+IS_DEBUG = True
+
+# kernels attention backend (Diffusers attention dispatcher)
+# '' or None: disabled. 'auto': Hopper->'_flash_3_hub' else ATTENTION_BACKEND_NON_HOPPER.
+ATTENTION_BACKEND = 'auto'
+ATTENTION_BACKEND_NON_HOPPER = 'flash_hub'
+
+
+# kernels hub prefetch (to avoid first-inference heavy download)
+# Notes:
+# - This does not remove the download requirement; it moves it to app startup.
+# - Add more repos if you also use 'flash_hub' (FlashAttention2) or 'sage_hub'.
+KERNELS_PREFETCH_ON_STARTUP = True
+KERNELS_PREFETCH_REPOS = [
+    "kernels-community/flash-attn3",
+    # "kernels-community/flash-attn2",
+    # "kernels-community/sage_attention",
+]