Upload 3 files

app.py

@@ -23,7 +23,7 @@ from mod import (clear_cache, get_repo_safetensors, is_repo_name, is_repo_exists
 from modutils import (search_civitai_lora, select_civitai_lora, search_civitai_lora_json,
                       download_my_lora_flux, get_all_lora_tupled_list, apply_lora_prompt_flux,
                       update_loras_flux, update_civitai_selection, get_civitai_tag, CIVITAI_SORT, CIVITAI_PERIOD,
-                      get_t2i_model_info, download_hf_file)
+                      get_t2i_model_info, download_hf_file, save_image_history)
 from tagger.tagger import predict_tags_wd, compose_prompt_to_copy
 from tagger.fl2flux import predict_tags_fl2_flux
 
@@ -741,9 +741,13 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
                     gr.Markdown("[Check the list of FLUX LoRAs](https://huggingface.co/models?other=base_model:adapter:black-forest-labs/FLUX.1-dev)", elem_id="lora_list")
             with gr.Column():
                 progress_bar = gr.Markdown(elem_id="progress",visible=False)
-                result = gr.Image(label="Generated Image", format="png", show_share_button=False, interactive=False)
+                result = gr.Image(label="Generated Image", format="png", type="filepath", show_share_button=False, interactive=False)
                 with gr.Accordion("History", open=False):
-                    history_gallery = gr.Gallery(label="History", columns=6, object_fit="contain", interactive=False)
+                    history_gallery = gr.Gallery(label="History", columns=6, object_fit="contain", interactive=False, format="png",
+                                                 show_share_button=False, show_download_button=True)
+                    history_files = gr.Files(interactive=False, visible=False)
+                    history_clear_button = gr.Button(value="Clear History", variant="secondary")
+                    history_clear_button.click(lambda: ([], []), None, [history_gallery, history_files], queue=False, show_api=False)
         with gr.Group():
             with gr.Row():
                 model_name = gr.Dropdown(label="Base Model", info="You can enter a huggingface model repo_id or path of single safetensors file to want to use.",
@@ -880,11 +884,11 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
         outputs=[result, seed, progress_bar],
         queue=True,
         show_api=True,
-    ).then(  # Update the history gallery
-        fn=lambda x, history: update_history(x, history),
-        inputs=[result, history_gallery],
-        outputs=history_gallery,
-    )
+    #).then(  # Update the history gallery
+    #    fn=lambda x, history: update_history(x, history),
+    #    inputs=[result, history_gallery],
+    #    outputs=history_gallery,
+    ).success(save_image_history, [result, history_gallery, history_files, model_name], [history_gallery, history_files], queue=False, show_api=False)
 
     input_image.upload(preprocess_i2i_image, [input_image, input_image_preprocess, height, width], [input_image], queue=False, show_api=False)
     gr.on(

env.py

@@ -3,7 +3,7 @@ import os
 
 CIVITAI_API_KEY = os.environ.get("CIVITAI_API_KEY")
 HF_TOKEN = os.environ.get("HF_TOKEN")
-hf_read_token = os.environ.get('HF_READ_TOKEN') # only use for private repo
+HF_READ_TOKEN = os.environ.get('HF_READ_TOKEN') # only use for private repo
 
 
 num_loras = 3
@@ -75,25 +75,25 @@ HF_MODEL_USER_LIKES = [] # sorted by number of likes
 HF_MODEL_USER_EX = [] # sorted by a special rule
 
 # - **Download Models**
-download_model_list = [
+DOWNLOAD_MODEL_LIST = [
 ]
 
 # - **Download VAEs**
-download_vae_list = [
+DOWNLOAD_VAE_LIST = [
 ]
 
 # - **Download LoRAs**
-download_lora_list = [
+DOWNLOAD_LORA_LIST = [
 ]
 
 DIFFUSERS_FORMAT_LORAS = []
 
-directory_models = 'models'
-os.makedirs(directory_models, exist_ok=True)
-directory_loras = 'loras'
-os.makedirs(directory_loras, exist_ok=True)
-directory_vaes = 'vaes'
-os.makedirs(directory_vaes, exist_ok=True)
+DIRECTORY_MODELS = 'models'
+os.makedirs(DIRECTORY_MODELS, exist_ok=True)
+DIRECTORY_LORAS = 'loras'
+os.makedirs(DIRECTORY_LORAS, exist_ok=True)
+DIRECTORY_VAES = 'vaes'
+os.makedirs(DIRECTORY_VAES, exist_ok=True)
 
 
 HF_LORA_PRIVATE_REPOS1 = []

modutils.py

@@ -5,6 +5,7 @@ import os
 import re
 from pathlib import Path
 from PIL import Image
+import numpy as np
 import shutil
 import requests
 from requests.adapters import HTTPAdapter
@@ -12,11 +13,16 @@ from urllib3.util import Retry
 import urllib.parse
 import pandas as pd
 from huggingface_hub import HfApi, HfFolder, hf_hub_download, snapshot_download
+from translatepy import Translator
+from unidecode import unidecode
+import copy
+from datetime import datetime, timezone, timedelta
+FILENAME_TIMEZONE = timezone(timedelta(hours=9)) # JST
 
 
 from env import (HF_LORA_PRIVATE_REPOS1, HF_LORA_PRIVATE_REPOS2,
     HF_MODEL_USER_EX, HF_MODEL_USER_LIKES, DIFFUSERS_FORMAT_LORAS,
-    directory_loras, hf_read_token, HF_TOKEN, CIVITAI_API_KEY)
+    DIRECTORY_LORAS, HF_READ_TOKEN, HF_TOKEN, CIVITAI_API_KEY)
 
 
 MODEL_TYPE_DICT = {
@@ -46,7 +52,6 @@ def is_repo_name(s):
     return re.fullmatch(r'^[^/]+?/[^/]+?$', s)
 
 
-from translatepy import Translator
 translator = Translator()
 def translate_to_en(input: str):
     try:
@@ -64,6 +69,7 @@ def get_local_model_list(dir_path):
         if file.suffix in valid_extensions:
             file_path = str(Path(f"{dir_path}/{file.name}"))
             model_list.append(file_path)
+            #print('\033[34mFILE: ' + file_path + '\033[0m')
     return model_list
 
 
@@ -98,21 +104,81 @@ def split_hf_url(url: str):
         print(e)
 
 
-def download_hf_file(directory, url, progress=gr.Progress(track_tqdm=True)):
-    hf_token = get_token()
+def download_hf_file(directory, url, force_filename="", hf_token="", progress=gr.Progress(track_tqdm=True)):
     repo_id, filename, subfolder, repo_type = split_hf_url(url)
+    kwargs = {}
+    if subfolder is not None: kwargs["subfolder"] = subfolder
+    if force_filename: kwargs["force_filename"] = force_filename
     try:
-        print(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)
+        print(f"Start downloading: {url} to {directory}")
+        path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type=repo_type, local_dir=directory, token=hf_token, **kwargs)
         return path
     except Exception as e:
-        print(f"Failed to download: {e}")
+        print(f"Download failed: {url} {e}")
         return None
 
 
-def download_things(directory, url, hf_token="", civitai_api_key=""):
+USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
+
+
+def request_json_data(url):
+    model_version_id = url.split('/')[-1]
+    if "?modelVersionId=" in model_version_id:
+        match = re.search(r'modelVersionId=(\d+)', url)
+        model_version_id = match.group(1)
+
+    endpoint_url = f"https://civitai.com/api/v1/model-versions/{model_version_id}"
+
+    params = {}
+    headers = {'User-Agent': USER_AGENT, 'content-type': 'application/json'}
+    session = requests.Session()
+    retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
+    session.mount("https://", HTTPAdapter(max_retries=retries))
+
+    try:
+        result = session.get(endpoint_url, params=params, headers=headers, stream=True, timeout=(3.0, 15))
+        result.raise_for_status()
+        json_data = result.json()
+        return json_data if json_data else None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+
+class ModelInformation:
+    def __init__(self, json_data):
+        self.model_version_id = json_data.get("id", "")
+        self.model_id = json_data.get("modelId", "")
+        self.download_url = json_data.get("downloadUrl", "")
+        self.model_url = f"https://civitai.com/models/{self.model_id}?modelVersionId={self.model_version_id}"
+        self.filename_url = next(
+            (v.get("name", "") for v in json_data.get("files", []) if str(self.model_version_id) in v.get("downloadUrl", "")), ""
+        )
+        self.filename_url = self.filename_url if self.filename_url else ""
+        self.description = json_data.get("description", "")
+        if self.description is None: self.description = ""
+        self.model_name = json_data.get("model", {}).get("name", "")
+        self.model_type = json_data.get("model", {}).get("type", "")
+        self.nsfw = json_data.get("model", {}).get("nsfw", False)
+        self.poi = json_data.get("model", {}).get("poi", False)
+        self.images = [img.get("url", "") for img in json_data.get("images", [])]
+        self.example_prompt = json_data.get("trainedWords", [""])[0] if json_data.get("trainedWords") else ""
+        self.original_json = copy.deepcopy(json_data)
+
+
+def retrieve_model_info(url):
+    json_data = request_json_data(url)
+    if not json_data:
+        return None
+    model_descriptor = ModelInformation(json_data)
+    return model_descriptor
+
+
+def download_things(directory, url, hf_token="", civitai_api_key="", romanize=False):
+    hf_token = get_token()
     url = url.strip()
+    downloaded_file_path = None
+
     if "drive.google.com" in url:
         original_dir = os.getcwd()
         os.chdir(directory)
@@ -123,18 +189,48 @@ def download_things(directory, url, hf_token="", civitai_api_key=""):
         # url = urllib.parse.quote(url, safe=':/')  # fix encoding
         if "/blob/" in url:
             url = url.replace("/blob/", "/resolve/")
-        download_hf_file(directory, url)
+
+        filename = unidecode(url.split('/')[-1]) if romanize else url.split('/')[-1]
+
+        download_hf_file(directory, url, filename, hf_token)
+
+        downloaded_file_path = os.path.join(directory, filename)
+
     elif "civitai.com" in url:
-        if "?" in url:
-            url = url.split("?")[0]
-        if civitai_api_key:
-            url = url + f"?token={civitai_api_key}"
-            os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
-        else:
+
+        if not civitai_api_key:
             print("\033[91mYou need an API key to download Civitai models.\033[0m")
+
+        model_profile = retrieve_model_info(url)
+        if model_profile.download_url and model_profile.filename_url:
+            url = model_profile.download_url
+            filename = unidecode(model_profile.filename_url) if romanize else model_profile.filename_url
+        else:
+            if "?" in url:
+                url = url.split("?")[0]
+            filename = ""
+
+        url_dl = url + f"?token={civitai_api_key}"
+        print(f"Filename: {filename}")
+
+        param_filename = ""
+        if filename:
+            param_filename = f"-o '{filename}'"
+
+        aria2_command = (
+            f'aria2c --console-log-level=error --summary-interval=10 -c -x 16 '
+            f'-k 1M -s 16 -d "{directory}" {param_filename} "{url_dl}"'
+        )
+        os.system(aria2_command)
+
+        if param_filename and os.path.exists(os.path.join(directory, filename)):
+            downloaded_file_path = os.path.join(directory, filename)
+
     else:
         os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
 
+    return downloaded_file_path
+
 
 def get_download_file(temp_dir, url, civitai_key="", progress=gr.Progress(track_tqdm=True)):
     if not "http" in url and is_repo_name(url) and not Path(url).exists():
@@ -173,7 +269,7 @@ def to_lora_key(path: str):
 
 def to_lora_path(key: str):
     if Path(key).is_file(): return key
-    path = Path(f"{directory_loras}/{escape_lora_basename(key)}.safetensors")
+    path = Path(f"{DIRECTORY_LORAS}/{escape_lora_basename(key)}.safetensors")
     return str(path)
 
 
@@ -203,25 +299,21 @@ def save_images(images: list[Image.Image], metadatas: list[str]):
         raise Exception(f"Failed to save image file:") from e
 
 
-def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
-    from datetime import datetime, timezone, timedelta
+def save_gallery_images(images, model_name="", progress=gr.Progress(track_tqdm=True)):
     progress(0, desc="Updating gallery...")
-    dt_now = datetime.now(timezone(timedelta(hours=9)))
-    basename = dt_now.strftime('%Y%m%d_%H%M%S_')
-    i = 1
-    if not images: return images, gr.update(visible=False)
+    basename = f"{model_name.split('/')[-1]}_{datetime.now(FILENAME_TIMEZONE).strftime('%Y%m%d_%H%M%S')}_"
+    if not images: return images, gr.update()
     output_images = []
     output_paths = []
-    for image in images:
-        filename = basename + str(i) + ".png"
-        i += 1
+    for i, image in enumerate(images):
+        filename = f"{basename}{str(i + 1)}.png"
         oldpath = Path(image[0])
         newpath = oldpath
         try:
             if oldpath.exists():
                 newpath = oldpath.resolve().rename(Path(filename).resolve())
         except Exception as e:
-           print(e)
+            print(e)
         finally: 
             output_paths.append(str(newpath))
             output_images.append((str(newpath), str(filename)))
@@ -229,10 +321,47 @@ def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
     return gr.update(value=output_images), gr.update(value=output_paths, visible=True)
 
 
+def save_gallery_history(images, files, history_gallery, history_files, progress=gr.Progress(track_tqdm=True)):
+    if not images or not files: return gr.update(), gr.update()
+    if not history_gallery: history_gallery = []
+    if not history_files: history_files = []
+    output_gallery = images + history_gallery
+    output_files = files + history_files
+    return gr.update(value=output_gallery), gr.update(value=output_files, visible=True)
+
+
+def save_image_history(image, gallery, files, model_name: str, progress=gr.Progress(track_tqdm=True)):
+    if not gallery: gallery = []
+    if not files: files = []
+    try:
+        basename = f"{model_name.split('/')[-1]}_{datetime.now(FILENAME_TIMEZONE).strftime('%Y%m%d_%H%M%S')}"
+        if image is None or not isinstance(image, (str, Image.Image, np.ndarray, tuple)): return gr.update(), gr.update()
+        filename = f"{basename}.png"
+        if isinstance(image, tuple): image = image[0]
+        if isinstance(image, str): oldpath = image
+        elif isinstance(image, Image.Image):
+            oldpath = "temp.png"
+            image.save(oldpath)
+        elif isinstance(image, np.ndarray):
+            oldpath = "temp.png"
+            Image.fromarray(image).convert('RGBA').save(oldpath)
+        oldpath = Path(oldpath)
+        newpath = oldpath
+        if oldpath.exists():
+            shutil.copy(oldpath.resolve(), Path(filename).resolve())
+            newpath = Path(filename).resolve()
+        files.insert(0, str(newpath))
+        gallery.insert(0, (str(newpath), str(filename)))
+    except Exception as e:
+        print(e)
+    finally: 
+        return gr.update(value=gallery), gr.update(value=files, visible=True)
+
+
 def download_private_repo(repo_id, dir_path, is_replace):
-    if not hf_read_token: return
+    if not HF_READ_TOKEN: return
     try:
-        snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], use_auth_token=hf_read_token)
+        snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], token=HF_READ_TOKEN)
     except Exception as e:
         print(f"Error: Failed to download {repo_id}.")
         print(e)
@@ -250,9 +379,9 @@ private_model_path_repo_dict = {} # {"local filepath": "huggingface repo_id", ..
 def get_private_model_list(repo_id, dir_path):
     global private_model_path_repo_dict
     api = HfApi()
-    if not hf_read_token: return []
+    if not HF_READ_TOKEN: return []
     try:
-        files = api.list_repo_files(repo_id, token=hf_read_token)
+        files = api.list_repo_files(repo_id, token=HF_READ_TOKEN)
     except Exception as e:
         print(f"Error: Failed to list {repo_id}.")
         print(e)
@@ -270,11 +399,11 @@ def get_private_model_list(repo_id, dir_path):
 def download_private_file(repo_id, path, is_replace):
     file = Path(path)
     newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}') if is_replace else file
-    if not hf_read_token or newpath.exists(): return
+    if not HF_READ_TOKEN or newpath.exists(): return
     filename = file.name
     dirname = file.parent.name
     try:
-        hf_hub_download(repo_id=repo_id, filename=filename, local_dir=dirname, use_auth_token=hf_read_token)
+        hf_hub_download(repo_id=repo_id, filename=filename, local_dir=dirname, token=HF_READ_TOKEN)
     except Exception as e:
         print(f"Error: Failed to download {filename}.")
         print(e)
@@ -404,9 +533,9 @@ def get_private_lora_model_lists():
     models1 = []
     models2 = []
     for repo in HF_LORA_PRIVATE_REPOS1:
-        models1.extend(get_private_model_list(repo, directory_loras))
+        models1.extend(get_private_model_list(repo, DIRECTORY_LORAS))
     for repo in HF_LORA_PRIVATE_REPOS2:
-        models2.extend(get_private_model_list(repo, directory_loras))
+        models2.extend(get_private_model_list(repo, DIRECTORY_LORAS))
     models = list_uniq(models1 + sorted(models2))
     private_lora_model_list = models.copy()
     return models
@@ -451,7 +580,7 @@ def get_civitai_info(path):
 
 
 def get_lora_model_list():
-    loras = list_uniq(get_private_lora_model_lists() + DIFFUSERS_FORMAT_LORAS + get_local_model_list(directory_loras))
+    loras = list_uniq(get_private_lora_model_lists() + DIFFUSERS_FORMAT_LORAS + get_local_model_list(DIRECTORY_LORAS))
     loras.insert(0, "None")
     loras.insert(0, "")
     return loras
@@ -503,14 +632,14 @@ def update_lora_dict(path):
 def download_lora(dl_urls: str):
     global loras_url_to_path_dict
     dl_path = ""
-    before = get_local_model_list(directory_loras)
+    before = get_local_model_list(DIRECTORY_LORAS)
     urls = []
     for url in [url.strip() for url in dl_urls.split(',')]:
-        local_path = f"{directory_loras}/{url.split('/')[-1]}"
+        local_path = f"{DIRECTORY_LORAS}/{url.split('/')[-1]}"
         if not Path(local_path).exists():
-            download_things(directory_loras, url, HF_TOKEN, CIVITAI_API_KEY)
+            download_things(DIRECTORY_LORAS, url, HF_TOKEN, CIVITAI_API_KEY)
             urls.append(url)
-    after = get_local_model_list(directory_loras)
+    after = get_local_model_list(DIRECTORY_LORAS)
     new_files = list_sub(after, before)
     i = 0
     for file in new_files:
@@ -761,12 +890,14 @@ def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3,
      gr.update(value=tag5, label=label5, visible=on5), gr.update(visible=on5), gr.update(value=md5, visible=on5)
 
 
-def get_my_lora(link_url):
-    before = get_local_model_list(directory_loras)
+def get_my_lora(link_url, romanize):
+    l_name = ""
+    l_path = ""
+    before = get_local_model_list(DIRECTORY_LORAS)
     for url in [url.strip() for url in link_url.split(',')]:
-        if not Path(f"{directory_loras}/{url.split('/')[-1]}").exists():
-            download_things(directory_loras, url, HF_TOKEN, CIVITAI_API_KEY)
-    after = get_local_model_list(directory_loras)
+        if not Path(f"{DIRECTORY_LORAS}/{url.split('/')[-1]}").exists():
+            l_name = download_things(DIRECTORY_LORAS, url, HF_TOKEN, CIVITAI_API_KEY, romanize)
+    after = get_local_model_list(DIRECTORY_LORAS)
     new_files = list_sub(after, before)
     for file in new_files:
         path = Path(file)
@@ -774,11 +905,16 @@ def get_my_lora(link_url):
             new_path = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
             path.resolve().rename(new_path.resolve())
             update_lora_dict(str(new_path))
+            l_path = str(new_path)
     new_lora_model_list = get_lora_model_list()
     new_lora_tupled_list = get_all_lora_tupled_list()
-    
+    msg_lora = "Downloaded"
+    if l_name:
+        msg_lora += f": <b>{l_name}</b>"
+        print(msg_lora)
+
     return gr.update(
-        choices=new_lora_tupled_list, value=new_lora_model_list[-1]
+        choices=new_lora_tupled_list, value=l_path
     ), gr.update(
         choices=new_lora_tupled_list
     ), gr.update(
@@ -787,6 +923,8 @@ def get_my_lora(link_url):
         choices=new_lora_tupled_list
     ), gr.update(
         choices=new_lora_tupled_list
+    ), gr.update(
+        value=msg_lora
     )
 
 
@@ -794,12 +932,12 @@ def upload_file_lora(files, progress=gr.Progress(track_tqdm=True)):
     progress(0, desc="Uploading...")
     file_paths = [file.name for file in files]
     progress(1, desc="Uploaded.")
-    return gr.update(value=file_paths, visible=True), gr.update(visible=True)
+    return gr.update(value=file_paths, visible=True), gr.update()
 
 
 def move_file_lora(filepaths):
     for file in filepaths:
-        path = Path(shutil.move(Path(file).resolve(), Path(f"./{directory_loras}").resolve()))
+        path = Path(shutil.move(Path(file).resolve(), Path(f"./{DIRECTORY_LORAS}").resolve()))
         newpath = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
         path.resolve().rename(newpath.resolve())
         update_lora_dict(str(newpath))
@@ -941,7 +1079,7 @@ def update_civitai_selection(evt: gr.SelectData):
         selected = civitai_last_choices[selected_index][1]
         return gr.update(value=selected)
     except Exception:
-        return gr.update(visible=True)
+        return gr.update()
 
 
 def select_civitai_lora(search_result):
@@ -1425,3 +1563,78 @@ def get_model_pipeline(repo_id: str):
     else:
         return default
 
+
+EXAMPLES_GUI = [
+    [
+        "1girl, souryuu asuka langley, neon genesis evangelion, plugsuit, pilot suit, red bodysuit, sitting, crossing legs, black eye patch, cat hat, throne, symmetrical, looking down, from bottom, looking at viewer, outdoors, masterpiece, best quality, very aesthetic, absurdres",
+        "nsfw, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
+        1,
+        30,
+        7.5,
+        True,
+        -1,
+        "Euler a",
+        1152,
+        896,
+        "votepurchase/animagine-xl-3.1",
+    ],
+    [
+        "solo, princess Zelda OOT, score_9, score_8_up, score_8, medium breasts, cute, eyelashes, cute small face, long hair, crown braid, hairclip, pointy ears, soft curvy body, looking at viewer, smile, blush, white dress, medium body, (((holding the Master Sword))), standing, deep forest in the background",
+        "score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white,",
+        1,
+        30,
+        5.,
+        True,
+        -1,
+        "Euler a",
+        1024,
+        1024,
+        "votepurchase/ponyDiffusionV6XL",
+    ],
+    [
+        "1girl, oomuro sakurako, yuru yuri, official art, school uniform, anime artwork, anime style, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres",
+        "photo, deformed, black and white, realism, disfigured, low contrast, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
+        1,
+        40,
+        7.0,
+        True,
+        -1,
+        "Euler a",
+        1024,
+        1024,
+        "Raelina/Rae-Diffusion-XL-V2",
+    ],
+    [
+        "1girl, akaza akari, yuru yuri, official art, anime artwork, anime style, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres",
+        "photo, deformed, black and white, realism, disfigured, low contrast, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
+        1,
+        35,
+        7.0,
+        True,
+        -1,
+        "Euler a",
+        1024,
+        1024,
+        "Raelina/Raemu-XL-V4",
+    ],
+    [
+        "yoshida yuuko, machikado mazoku, 1girl, solo, demon horns,horns, school uniform, long hair, open mouth, skirt, demon girl, ahoge, shiny, shiny hair, anime artwork",
+        "nsfw, lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
+        1,
+        50,
+        7.,
+        True,
+        -1,
+        "Euler a",
+        1024,
+        1024,
+        "cagliostrolab/animagine-xl-3.1",
+    ],
+]
+
+
+RESOURCES = (
+    """### Resources
+    - You can also try the image generator in Colab’s free tier, which provides free GPU [link](https://github.com/R3gm/SD_diffusers_interactive).
+    """
+)