1121 lines
55 KiB
Python
1121 lines
55 KiB
Python
import requests
|
|
import json
|
|
import gradio as gr
|
|
import urllib.request
|
|
import urllib.parse
|
|
import urllib.error
|
|
import os
|
|
import re
|
|
import datetime
|
|
import platform
|
|
from PIL import Image
|
|
from io import BytesIO
|
|
from collections import defaultdict
|
|
from modules.images import read_info_from_image
|
|
from modules.shared import cmd_opts, opts
|
|
from modules.paths import models_path, extensions_dir, data_path
|
|
from html import escape
|
|
import scripts.civitai_global as gl
|
|
import scripts.civitai_download as _download
|
|
try:
|
|
from fake_useragent import UserAgent
|
|
except:
|
|
print(f"{gl.print} Python module 'fake_useragent' has not been imported correctly, please try to restart or install it manually.")
|
|
|
|
gl.init()
|
|
|
|
def contenttype_folder(content_type, desc=None, fromCheck=False, custom_folder=None):
|
|
use_LORA = getattr(opts, "use_LORA", False)
|
|
folder = None
|
|
if desc:
|
|
desc = desc.upper()
|
|
else:
|
|
desc = "PLACEHOLDER"
|
|
if custom_folder:
|
|
main_models = custom_folder
|
|
main_data = custom_folder
|
|
else:
|
|
main_models = models_path
|
|
main_data = data_path
|
|
|
|
if content_type == "modelFolder":
|
|
folder = os.path.join(main_models)
|
|
|
|
if content_type == "Checkpoint":
|
|
if cmd_opts.ckpt_dir and not custom_folder:
|
|
folder = cmd_opts.ckpt_dir
|
|
else:
|
|
folder = os.path.join(main_models,"Stable-diffusion")
|
|
|
|
elif content_type == "Hypernetwork":
|
|
if cmd_opts.hypernetwork_dir and not custom_folder:
|
|
folder = cmd_opts.hypernetwork_dir
|
|
else:
|
|
folder = os.path.join(main_models, "hypernetworks")
|
|
|
|
elif content_type == "TextualInversion":
|
|
if cmd_opts.embeddings_dir and not custom_folder:
|
|
folder = cmd_opts.embeddings_dir
|
|
else:
|
|
folder = os.path.join(main_data, "embeddings")
|
|
|
|
elif content_type == "AestheticGradient":
|
|
if not custom_folder:
|
|
folder = os.path.join(extensions_dir, "stable-diffusion-webui-aesthetic-gradients", "aesthetic_embeddings")
|
|
else:
|
|
folder = os.path.join(custom_folder, "aesthetic_embeddings")
|
|
elif content_type == "LORA":
|
|
if cmd_opts.lora_dir and not custom_folder:
|
|
folder = cmd_opts.lora_dir
|
|
else:
|
|
folder = folder = os.path.join(main_models, "Lora")
|
|
|
|
elif content_type == "LoCon":
|
|
folder = os.path.join(main_models, "LyCORIS")
|
|
if use_LORA and not fromCheck:
|
|
if cmd_opts.lora_dir and not custom_folder:
|
|
folder = cmd_opts.lora_dir
|
|
else:
|
|
folder = folder = os.path.join(main_models, "Lora")
|
|
|
|
elif content_type == "VAE":
|
|
if cmd_opts.vae_dir and not custom_folder:
|
|
folder = cmd_opts.vae_dir
|
|
else:
|
|
folder = os.path.join(main_models, "VAE")
|
|
|
|
elif content_type == "Controlnet":
|
|
folder = os.path.join(main_models, "ControlNet")
|
|
|
|
elif content_type == "Poses":
|
|
folder = os.path.join(main_models, "Poses")
|
|
|
|
elif content_type == "Upscaler":
|
|
if "SWINIR" in desc:
|
|
if cmd_opts.swinir_models_path and not custom_folder:
|
|
folder = cmd_opts.swinir_models_path
|
|
else:
|
|
folder = os.path.join(main_models, "SwinIR")
|
|
elif "REALESRGAN" in desc:
|
|
if cmd_opts.realesrgan_models_path and not custom_folder:
|
|
folder = cmd_opts.realesrgan_models_path
|
|
else:
|
|
folder = os.path.join(main_models, "RealESRGAN")
|
|
elif "GFPGAN" in desc:
|
|
if cmd_opts.gfpgan_models_path and not custom_folder:
|
|
folder = cmd_opts.gfpgan_models_path
|
|
else:
|
|
folder = os.path.join(main_models, "GFPGAN")
|
|
elif "BSRGAN" in desc:
|
|
if cmd_opts.bsrgan_models_path and not custom_folder:
|
|
folder = cmd_opts.bsrgan_models_path
|
|
else:
|
|
folder = os.path.join(main_models, "BSRGAN")
|
|
else:
|
|
if cmd_opts.esrgan_models_path and not custom_folder:
|
|
folder = cmd_opts.esrgan_models_path
|
|
else:
|
|
folder = os.path.join(main_models, "ESRGAN")
|
|
|
|
elif content_type == "MotionModule":
|
|
folder = os.path.join(extensions_dir, "sd-webui-animatediff", "model")
|
|
|
|
elif content_type == "Workflows":
|
|
folder = os.path.join(main_models, "Workflows")
|
|
|
|
elif content_type == "Other":
|
|
if "ADETAILER" in desc:
|
|
folder = os.path.join(main_models, "adetailer")
|
|
else:
|
|
folder = os.path.join(main_models, "Other")
|
|
|
|
elif content_type == "Wildcards":
|
|
folder = os.path.join(extensions_dir, "UnivAICharGen", "wildcards")
|
|
if not os.path.exists(folder):
|
|
folder = os.path.join(extensions_dir, "sd-dynamic-prompts", "wildcards")
|
|
|
|
return folder
|
|
|
|
def api_to_data(content_type, sort_type, period_type, use_search_term, current_page, base_filter, only_liked, tile_count, search_term=None, nsfw=None, timeOut=None, isNext=None, inputs_changed=None):
|
|
if current_page in [0, None, ""]:
|
|
current_page = 1
|
|
if inputs_changed:
|
|
gl.file_scan = False
|
|
api_url = f"https://civitai.com/api/v1/models?limit={tile_count}&page=1"
|
|
else:
|
|
api_url = f"https://civitai.com/api/v1/models?limit={tile_count}&page={current_page}"
|
|
|
|
if timeOut:
|
|
if isNext:
|
|
next_page = str(int(current_page) + 1)
|
|
else:
|
|
if current_page not in [1, 0, None, ""]:
|
|
next_page = str(int(current_page) - 1)
|
|
api_url = f"https://civitai.com/api/v1/models?limit={tile_count}&page={next_page}"
|
|
|
|
if period_type:
|
|
period_type = period_type.replace(" ", "")
|
|
query = {'sort': sort_type, 'period': period_type}
|
|
|
|
types_query_str = ""
|
|
|
|
if content_type:
|
|
types_query_str = "".join([f"&types={type}" for type in content_type])
|
|
|
|
query_str = urllib.parse.urlencode(query, quote_via=urllib.parse.quote)
|
|
|
|
if types_query_str:
|
|
query_str += types_query_str
|
|
|
|
if use_search_term != "None" and search_term:
|
|
search_term = search_term.replace("\\","\\\\")
|
|
if "civitai.com" in search_term:
|
|
match = re.search(r'models/(\d+)', search_term)
|
|
model_number = match.group(1)
|
|
query_str = f"&ids={urllib.parse.quote(model_number)}"
|
|
elif use_search_term == "User name":
|
|
query_str += f"&username={urllib.parse.quote(search_term)}"
|
|
elif use_search_term == "Tag":
|
|
query_str += f"&tag={urllib.parse.quote(search_term)}"
|
|
else:
|
|
query_str += f"&query={urllib.parse.quote(search_term)}"
|
|
|
|
if base_filter:
|
|
for base in base_filter:
|
|
query_str += f"&baseModels={urllib.parse.quote(base)}"
|
|
|
|
if only_liked:
|
|
query_str += f"&favorites=true"
|
|
|
|
if nsfw == False:
|
|
query_str += f"&nsfw=false"
|
|
|
|
full_url = f"{api_url}&{query_str}"
|
|
|
|
if gl.file_scan:
|
|
highest_number = max(gl.url_list_with_numbers.keys())
|
|
full_url = gl.url_list_with_numbers.get(int(current_page))
|
|
nextPage = int(current_page) + 1
|
|
prevPage = int(current_page) - 1
|
|
data = request_civit_api(full_url)
|
|
data["metadata"]["currentPage"] = current_page
|
|
data["metadata"]["totalPages"] = highest_number
|
|
if not nextPage > highest_number:
|
|
data["metadata"]["nextPage"] = gl.url_list_with_numbers.get(nextPage)
|
|
if not prevPage == 0:
|
|
data["metadata"]["prevPage"] = gl.url_list_with_numbers.get(prevPage)
|
|
else:
|
|
data = request_civit_api(full_url)
|
|
|
|
return data
|
|
|
|
def model_list_html(json_data, model_dict):
|
|
video_playback = getattr(opts, "video_playback", True)
|
|
playback = ""
|
|
if video_playback: playback = "autoplay loop"
|
|
|
|
hide_early_access = getattr(opts, "hide_early_access", True)
|
|
filtered_items = []
|
|
current_time = datetime.datetime.utcnow()
|
|
|
|
for item in json_data['items']:
|
|
versions_to_keep = []
|
|
|
|
for version in item['modelVersions']:
|
|
if not version['publishedAt'] or not version['files']:
|
|
continue
|
|
if hide_early_access:
|
|
early_access_days = version['earlyAccessTimeFrame']
|
|
if early_access_days != 0:
|
|
published_at = datetime.datetime.strptime(version['publishedAt'], "%Y-%m-%dT%H:%M:%S.%fZ")
|
|
adjusted_date = published_at + datetime.timedelta(days=early_access_days)
|
|
if not current_time > adjusted_date:
|
|
continue
|
|
versions_to_keep.append(version)
|
|
|
|
if versions_to_keep:
|
|
item['modelVersions'] = versions_to_keep
|
|
filtered_items.append(item)
|
|
|
|
json_data['items'] = filtered_items
|
|
|
|
HTML = '<div class="column civmodellist">'
|
|
sorted_models = {}
|
|
existing_files = set()
|
|
existing_files_sha256 = set()
|
|
model_folders = set()
|
|
|
|
for item in json_data['items']:
|
|
model_folder = os.path.join(contenttype_folder(item['type'], item['description']))
|
|
model_folders.add(model_folder)
|
|
|
|
for folder in model_folders:
|
|
for root, dirs, files in os.walk(folder):
|
|
for file in files:
|
|
existing_files.add(file)
|
|
if file.endswith('.json'):
|
|
json_path = os.path.join(root, file)
|
|
with open(json_path, 'r') as f:
|
|
try:
|
|
json_file = json.load(f)
|
|
if isinstance(json_file, dict):
|
|
sha256 = json_file.get('sha256')
|
|
if sha256:
|
|
existing_files_sha256.add(sha256.upper())
|
|
else:
|
|
print(f"{gl.print} Invalid JSON data in {json_path}. Expected a dictionary.")
|
|
except Exception as e:
|
|
print(f"{gl.print} Error decoding JSON in {json_path}: {e}")
|
|
|
|
for item in json_data['items']:
|
|
for k, model in model_dict.items():
|
|
if model_dict[k].lower() == item['name'].lower():
|
|
model_name = escape(item["name"].replace("\\", "\\\\").replace("'", "\\'"), quote=True)
|
|
|
|
nsfw = ""
|
|
installstatus = ""
|
|
baseModel = ""
|
|
try:
|
|
if 'baseModel' in item['modelVersions'][0]:
|
|
baseModel = item['modelVersions'][0]['baseModel']
|
|
except:
|
|
baseModel = "Not Found"
|
|
|
|
try:
|
|
if 'updatedAt' in item['modelVersions'][0]:
|
|
date = item['modelVersions'][0]['updatedAt'].split('T')[0]
|
|
except:
|
|
baseModel = "Not Found"
|
|
|
|
if gl.sortNewest:
|
|
if date not in sorted_models:
|
|
sorted_models[date] = []
|
|
|
|
if any(item['modelVersions']):
|
|
if len(item['modelVersions'][0]['images']) > 0:
|
|
if item["modelVersions"][0]["images"][0]['nsfw'] not in ["None", "Soft"]:
|
|
nsfw = "civcardnsfw"
|
|
media_type = item["modelVersions"][0]["images"][0]["type"]
|
|
image = item["modelVersions"][0]["images"][0]["url"]
|
|
if media_type == "video":
|
|
image = image.replace("width=", "transcode=true,width=")
|
|
imgtag = f'<video class="video-bg" {playback} muted playsinline><source src="{image}" type="video/mp4"></video>'
|
|
else:
|
|
imgtag = f'<img src="{image}"></img>'
|
|
else:
|
|
imgtag = f'<img src="./file=html/card-no-preview.png"></img>'
|
|
|
|
installstatus = None
|
|
|
|
for version in reversed(item['modelVersions']):
|
|
for file in version.get('files', []):
|
|
file_name = file['name']
|
|
file_sha256 = file.get('hashes', {}).get('SHA256', "").upper()
|
|
|
|
name_match = file_name in existing_files
|
|
sha256_match = file_sha256 in existing_files_sha256
|
|
if name_match or sha256_match:
|
|
if version == item['modelVersions'][0]:
|
|
installstatus = "civmodelcardinstalled"
|
|
else:
|
|
installstatus = "civmodelcardoutdated"
|
|
model_card = f'<figure class="civmodelcard {nsfw} {installstatus}" base-model="{baseModel}" date="{date}" onclick="select_model(\'{model_name}\', event)">'
|
|
if installstatus != "civmodelcardinstalled":
|
|
model_card += f'<input type="checkbox" class="model-checkbox" id="checkbox-{model_name}" onchange="multi_model_select(\'{model_name}\', this.checked)" style="opacity: 0; position: absolute; top: 10px; right: 10px;">' \
|
|
+ f'<label for="checkbox-{model_name}" class="custom-checkbox"></label>'
|
|
if len(item["name"]) > 40:
|
|
display_name = item["name"][:40] + '...'
|
|
else:
|
|
display_name = item["name"]
|
|
|
|
model_card += imgtag \
|
|
+ f'<figcaption title="{item["name"]}">{display_name}</figcaption></figure>'
|
|
|
|
if gl.sortNewest:
|
|
sorted_models[date].append(model_card)
|
|
else:
|
|
HTML += model_card
|
|
|
|
if gl.sortNewest:
|
|
for date, cards in sorted(sorted_models.items(), reverse=True):
|
|
HTML += f'<div class="date-section"><h4>{date}</h4><hr style="margin-bottom: 5px; margin-top: 5px;">'
|
|
HTML += '<div class="card-row">'
|
|
for card in cards:
|
|
HTML += card
|
|
HTML += '</div></div>'
|
|
|
|
HTML += '</div>'
|
|
return HTML
|
|
|
|
def update_prev_page(content_type, sort_type, period_type, use_search_term, search_term, current_page, base_filter, only_liked, nsfw, tile_count):
|
|
return update_next_page(content_type, sort_type, period_type, use_search_term, search_term, current_page, base_filter, only_liked, nsfw, tile_count, isNext=False)
|
|
|
|
def update_next_page(content_type, sort_type, period_type, use_search_term, search_term, current_page, base_filter, only_liked, nsfw, tile_count, isNext=True):
|
|
use_LORA = getattr(opts, "use_LORA", False)
|
|
|
|
if content_type:
|
|
if use_LORA and 'LORA & LoCon' in content_type:
|
|
content_type.remove('LORA & LoCon')
|
|
if 'LORA' not in content_type:
|
|
content_type.append('LORA')
|
|
if 'LoCon' not in content_type:
|
|
content_type.append('LoCon')
|
|
|
|
if gl.json_data is None or gl.json_data == "timeout":
|
|
timeOut = True
|
|
return_values = update_model_list(content_type, sort_type, period_type, use_search_term, search_term, current_page, base_filter, only_liked, nsfw, timeOut=timeOut, isNext=isNext)
|
|
timeOut = False
|
|
|
|
return return_values
|
|
|
|
current_inputs = (content_type, sort_type, period_type, use_search_term, search_term, tile_count, base_filter, nsfw)
|
|
if current_inputs != gl.previous_inputs and gl.previous_inputs != None:
|
|
inputs_changed = True
|
|
else:
|
|
inputs_changed = False
|
|
|
|
gl.previous_inputs = current_inputs
|
|
|
|
if not gl.file_scan:
|
|
if inputs_changed:
|
|
return_values = update_model_list(content_type, sort_type, period_type, use_search_term, search_term, current_page, base_filter, only_liked, nsfw, tile_count)
|
|
return return_values
|
|
|
|
if isNext:
|
|
if gl.json_data['metadata']['nextPage'] is not None:
|
|
gl.json_data = request_civit_api(gl.json_data['metadata']['nextPage'])
|
|
else:
|
|
gl.json_data = None
|
|
else:
|
|
if gl.json_data['metadata']['prevPage'] is not None:
|
|
gl.json_data = request_civit_api(gl.json_data['metadata']['prevPage'])
|
|
else:
|
|
gl.json_data = None
|
|
else:
|
|
highest_number = max(gl.url_list_with_numbers.keys())
|
|
if isNext:
|
|
if gl.json_data['metadata']['nextPage'] is not None:
|
|
currentPage = int(gl.json_data['metadata']['currentPage'])
|
|
nextPage = currentPage + 2
|
|
prevPage = currentPage
|
|
pageCount = currentPage + 1
|
|
gl.json_data = request_civit_api(gl.json_data['metadata']['nextPage'])
|
|
|
|
gl.json_data["metadata"]["totalPages"] = highest_number
|
|
if not nextPage > highest_number:
|
|
gl.json_data["metadata"]["nextPage"] = gl.url_list_with_numbers.get(nextPage)
|
|
if not prevPage == 0:
|
|
gl.json_data["metadata"]["prevPage"] = gl.url_list_with_numbers.get(prevPage)
|
|
gl.json_data["metadata"]["currentPage"] = pageCount
|
|
else:
|
|
gl.json_data = None
|
|
else:
|
|
if gl.json_data['metadata']['prevPage'] is not None:
|
|
currentPage = int(gl.json_data['metadata']['currentPage'])
|
|
nextPage = currentPage
|
|
prevPage = currentPage - 2
|
|
pageCount = currentPage - 1
|
|
gl.json_data = request_civit_api(gl.json_data['metadata']['prevPage'])
|
|
|
|
gl.json_data["metadata"]["totalPages"] = highest_number
|
|
if not nextPage > highest_number:
|
|
gl.json_data["metadata"]["nextPage"] = gl.url_list_with_numbers.get(nextPage)
|
|
if not prevPage == 0:
|
|
gl.json_data["metadata"]["prevPage"] = gl.url_list_with_numbers.get(prevPage)
|
|
gl.json_data["metadata"]["currentPage"] = pageCount
|
|
else:
|
|
gl.json_data = None
|
|
|
|
if gl.json_data is None:
|
|
return
|
|
|
|
if gl.json_data == "timeout":
|
|
HTML = '<div style="font-size: 24px; text-align: center; margin: 50px !important;">The Civit-API has timed out, please try again.<br>The servers might be too busy or down if the issue persists.</div>'
|
|
hasPrev = current_page not in [0, 1]
|
|
hasNext = current_page == 1 or hasPrev
|
|
model_dict = {}
|
|
|
|
if gl.json_data != None and gl.json_data != "timeout":
|
|
(hasPrev, hasNext, current_page, total_pages) = pagecontrol(gl.json_data)
|
|
model_dict = {}
|
|
try:
|
|
gl.json_data['items']
|
|
except TypeError:
|
|
return gr.Dropdown.update(choices=[], value=None)
|
|
|
|
for item in gl.json_data['items']:
|
|
model_dict[item['name']] = item['name']
|
|
HTML = model_list_html(gl.json_data, model_dict)
|
|
|
|
page_string = f"Page: {current_page}/{total_pages}"
|
|
|
|
return (
|
|
gr.Dropdown.update(choices=[v for k, v in model_dict.items()], value="", interactive=True), # Model List
|
|
gr.Dropdown.update(choices=[], value=""), # Version List
|
|
gr.HTML.update(value=HTML), # HTML Tiles
|
|
gr.Button.update(interactive=hasPrev), # Prev Page Button
|
|
gr.Button.update(interactive=hasNext), # Next Page Button
|
|
gr.Slider.update(value=current_page, maximum=total_pages, label=page_string), # Page Count
|
|
gr.Button.update(interactive=False), # Save Tags
|
|
gr.Button.update(interactive=False), # Save Images
|
|
gr.Button.update(interactive=False, visible=False if gl.isDownloading else True), # Download Button
|
|
gr.Button.update(interactive=False, visible=False), # Delete Button
|
|
gr.Textbox.update(interactive=False, value=None), # Install Path
|
|
gr.Dropdown.update(choices=[], value="", interactive=False), # Sub Folder List
|
|
gr.Dropdown.update(choices=[], value="", interactive=False), # File List
|
|
gr.HTML.update(value='<div style="min-height: 0px;"></div>'), # Preview HTML
|
|
gr.Textbox.update(value=None), # Trained Tags
|
|
gr.Textbox.update(value=None), # Base Model
|
|
gr.Textbox.update(value=None) # Model Filename
|
|
)
|
|
|
|
def pagecontrol(json_data):
|
|
current_page = f"{json_data['metadata']['currentPage']}"
|
|
total_pages = f"{json_data['metadata']['totalPages']}"
|
|
hasNext = False
|
|
hasPrev = False
|
|
if 'nextPage' in json_data['metadata']:
|
|
hasNext = True
|
|
if 'prevPage' in json_data['metadata']:
|
|
hasPrev = True
|
|
return hasPrev, hasNext, current_page, total_pages
|
|
|
|
def update_model_list(content_type=None, sort_type=None, period_type=None, use_search_term=None, search_term=None, current_page=None, base_filter=None, only_liked=None, nsfw=None, tile_count=None, timeOut=None, isNext=None, from_ver=False, from_installed=False):
|
|
use_LORA = getattr(opts, "use_LORA", False)
|
|
|
|
if content_type:
|
|
if use_LORA and 'LORA & LoCon' in content_type:
|
|
content_type.remove('LORA & LoCon')
|
|
if 'LORA' not in content_type:
|
|
content_type.append('LORA')
|
|
if 'LoCon' not in content_type:
|
|
content_type.append('LoCon')
|
|
|
|
if not from_ver and not from_installed:
|
|
gl.ver_json = None
|
|
if not gl.file_scan:
|
|
|
|
current_inputs = (content_type, sort_type, period_type, use_search_term, search_term, tile_count, base_filter, nsfw)
|
|
|
|
if current_inputs != gl.previous_inputs and gl.previous_inputs != None:
|
|
inputs_changed = True
|
|
else:
|
|
inputs_changed = False
|
|
|
|
gl.previous_inputs = current_inputs
|
|
|
|
gl.json_data = api_to_data(content_type, sort_type, period_type, use_search_term, current_page, base_filter, only_liked, tile_count, search_term, nsfw, timeOut, isNext, inputs_changed)
|
|
if gl.json_data == "timeout":
|
|
HTML = '<div style="font-size: 24px; text-align: center; margin: 50px !important;">The Civit-API has timed out, please try again.<br>The servers might be too busy or down if the issue persists.</div>'
|
|
hasPrev = current_page not in [0, 1]
|
|
hasNext = current_page == 1 or hasPrev
|
|
model_dict = {}
|
|
|
|
if gl.json_data is None:
|
|
return
|
|
|
|
if from_installed or from_ver:
|
|
gl.json_data = gl.ver_json
|
|
|
|
if gl.json_data != None and gl.json_data != "timeout":
|
|
if not from_ver:
|
|
(hasPrev, hasNext, current_page, total_pages) = pagecontrol(gl.json_data)
|
|
else:
|
|
current_page = 1
|
|
total_pages = 1
|
|
hasPrev = False
|
|
hasNext = False
|
|
model_dict = {}
|
|
for item in gl.json_data['items']:
|
|
model_dict[item['name']] = item['name']
|
|
|
|
HTML = model_list_html(gl.json_data, model_dict)
|
|
else:
|
|
current_page = 1
|
|
total_pages = 1
|
|
|
|
page_string = f"Page: {current_page}/{total_pages}"
|
|
|
|
return (
|
|
gr.Dropdown.update(choices=[v for k, v in model_dict.items()], value="", interactive=True), # Model List
|
|
gr.Dropdown.update(choices=[], value=""), # Version List
|
|
gr.HTML.update(value=HTML), # HTML Tiles
|
|
gr.Button.update(interactive=hasPrev), # Prev Page Button
|
|
gr.Button.update(interactive=hasNext), # Next Page Button
|
|
gr.Slider.update(value=current_page, maximum=total_pages, label=page_string), # Page Count
|
|
gr.Button.update(interactive=False), # Save Tags
|
|
gr.Button.update(interactive=False), # Save Images
|
|
gr.Button.update(interactive=False, visible=False if gl.isDownloading else True), # Download Button
|
|
gr.Button.update(interactive=False, visible=False), # Delete Button
|
|
gr.Textbox.update(interactive=False, value=None, visible=True), # Install Path
|
|
gr.Dropdown.update(choices=[], value="", interactive=False), # Sub Folder List
|
|
gr.Dropdown.update(choices=[], value="", interactive=False), # File List
|
|
gr.HTML.update(value='<div style="min-height: 0px;"></div>'), # Preview HTML
|
|
gr.Textbox.update(value=None), # Trained Tags
|
|
gr.Textbox.update(value=None), # Base Model
|
|
gr.Textbox.update(value=None) # Model Filename
|
|
)
|
|
|
|
def update_model_versions(model_name):
|
|
item_names_and_types = {item['name']: (item['type'], item['description']) for item in gl.json_data['items']}
|
|
|
|
if model_name is not None:
|
|
selected_content_type, desc = item_names_and_types.get(model_name, (None, None))
|
|
if selected_content_type is None:
|
|
print(f"{gl.print} Model name not found in json_data. (update_model_versions)")
|
|
return
|
|
|
|
versions_dict = defaultdict(list)
|
|
installed_versions = set()
|
|
|
|
model_folder = os.path.join(contenttype_folder(selected_content_type, desc))
|
|
gl.main_folder = model_folder
|
|
|
|
item = next((item for item in gl.json_data['items'] if item['name'] == model_name), None)
|
|
if item is None:
|
|
return
|
|
versions = item['modelVersions']
|
|
|
|
version_files = set()
|
|
for version in versions:
|
|
versions_dict[version['name']].append(item["name"])
|
|
for version_file in version['files']:
|
|
file_sha256 = version_file.get('hashes', {}).get('SHA256', "").upper()
|
|
version_filename = version_file['name']
|
|
version_files.add((version['name'], version_filename, file_sha256))
|
|
|
|
for root, _, files in os.walk(model_folder):
|
|
for file in files:
|
|
if file.endswith('.json'):
|
|
try:
|
|
json_path = os.path.join(root, file)
|
|
with open(json_path, 'r') as f:
|
|
json_data = json.load(f)
|
|
if isinstance(json_data, dict):
|
|
if 'sha256' in json_data:
|
|
sha256 = json_data.get('sha256', "").upper()
|
|
for version_name, _, file_sha256 in version_files:
|
|
if sha256 == file_sha256:
|
|
installed_versions.add(version_name)
|
|
break
|
|
except Exception as e:
|
|
print(f"{gl.print} failed to read: \"{file}\": {e}")
|
|
|
|
for version_name, version_filename, _ in version_files:
|
|
if file == version_filename:
|
|
installed_versions.add(version_name)
|
|
break
|
|
|
|
version_names = list(versions_dict.keys())
|
|
display_version_names = [f"{v} [Installed]" if v in installed_versions else v for v in version_names]
|
|
default_installed = next((f"{v} [Installed]" for v in installed_versions), None)
|
|
default_value = default_installed or next(iter(version_names), None)
|
|
|
|
return gr.Dropdown.update(choices=display_version_names, value=default_value, interactive=True) # Version List
|
|
else:
|
|
return gr.Dropdown.update(choices=[], value=None, interactive=False) # Version List
|
|
|
|
def cleaned_name(file_name):
|
|
if platform.system() == "Windows":
|
|
illegal_chars_pattern = r'[\\/:*?"<>|]'
|
|
else:
|
|
illegal_chars_pattern = r'/'
|
|
|
|
name, extension = os.path.splitext(file_name)
|
|
clean_name = re.sub(illegal_chars_pattern, '', name)
|
|
|
|
return f"{clean_name}{extension}"
|
|
|
|
def fetch_and_process_image(image_url):
|
|
response = requests.get(image_url)
|
|
if response.status_code == 200:
|
|
image = Image.open(BytesIO(response.content))
|
|
geninfo, _ = read_info_from_image(image)
|
|
return geninfo
|
|
return None
|
|
|
|
def update_model_info(model_name=None, model_version=None):
|
|
video_playback = getattr(opts, "video_playback", True)
|
|
playback = ""
|
|
if video_playback: playback = "autoplay loop"
|
|
|
|
BtnDownInt = True
|
|
BtnDel = False
|
|
BtnImage = False
|
|
|
|
if model_version and "[Installed]" in model_version:
|
|
model_version = model_version.replace(" [Installed]", "")
|
|
if model_name and model_version:
|
|
output_html = ""
|
|
output_training = ""
|
|
output_basemodel = ""
|
|
img_html = ""
|
|
dl_dict = {}
|
|
is_LORA = False
|
|
file_list = []
|
|
model_filename = None
|
|
model_id = None
|
|
sha256_value = None
|
|
for item in gl.json_data['items']:
|
|
if item['name'] == model_name:
|
|
content_type = item['type']
|
|
if content_type == "LORA":
|
|
is_LORA = True
|
|
desc = item['description']
|
|
model_id = item['id']
|
|
model_folder = os.path.join(contenttype_folder(content_type, desc))
|
|
model_uploader = item['creator']['username']
|
|
uploader_avatar = item['creator']['image']
|
|
if uploader_avatar is None:
|
|
uploader_avatar = ''
|
|
else:
|
|
uploader_avatar = f'<div class="avatar"><img src={uploader_avatar}></div>'
|
|
tags = item.get('tags', "")
|
|
model_desc = item.get('description', "")
|
|
for model in item['modelVersions']:
|
|
if model['name'] == model_version:
|
|
if model['trainedWords']:
|
|
output_training = ",".join(model['trainedWords'])
|
|
output_training = re.sub(r'<[^>]*:[^>]*>', '', output_training)
|
|
output_training = re.sub(r', ?', ', ', output_training)
|
|
output_training = output_training.strip(', ')
|
|
if model['baseModel']:
|
|
output_basemodel = model['baseModel']
|
|
for file in model['files']:
|
|
dl_dict[file['name']] = file['downloadUrl']
|
|
|
|
if not model_filename:
|
|
model_filename = file['name']
|
|
dl_url = file['downloadUrl']
|
|
gl.json_info = item
|
|
sha256_value = file['hashes'].get('SHA256', 'Unknown')
|
|
|
|
size = file['metadata'].get('size', 'Unknown')
|
|
format = file['metadata'].get('format', 'Unknown')
|
|
fp = file['metadata'].get('fp', 'Unknown')
|
|
sizeKB = file.get('sizeKB', 0) * 1024
|
|
filesize = _download.convert_size(sizeKB)
|
|
|
|
unique_file_name = f"{size} {format} {fp} ({filesize})"
|
|
file_list.append(unique_file_name)
|
|
|
|
if is_LORA and file_list:
|
|
extracted_formats = [file.split(' ')[1] for file in file_list]
|
|
|
|
if "SafeTensor" in extracted_formats and "PickleTensor" in extracted_formats:
|
|
if "PickleTensor" in file_list[0].split(' ')[1]:
|
|
if float(file_list[0].split(' ')[0]) <= 100:
|
|
model_folder = os.path.join(contenttype_folder("TextualInversion"))
|
|
|
|
model_url = model['downloadUrl']
|
|
model_main_url = f"https://civitai.com/models/{item['id']}"
|
|
img_html = '<div class="sampleimgs"><input type="radio" name="zoomRadio" id="resetZoom" class="zoom-radio" checked>'
|
|
for index, pic in enumerate(model['images']):
|
|
meta_button = False
|
|
meta = pic['meta']
|
|
if meta and meta.get('prompt'):
|
|
meta_button = True
|
|
BtnImage = True
|
|
# Change width value in URL to original image width
|
|
image_url = re.sub(r'/width=\d+', f'/width={pic["width"]}', pic["url"])
|
|
if pic['type'] == "video":
|
|
image_url = image_url.replace("width=", "transcode=true,width=")
|
|
nsfw = 'class="model-block"'
|
|
|
|
if pic['nsfw'] not in ["None", "Soft"]:
|
|
nsfw = 'class="civnsfw model-block"'
|
|
|
|
img_html += f'''
|
|
<div {nsfw} style="display:flex;align-items:flex-start;">
|
|
<div class="civitai-image-container">
|
|
<input type="radio" name="zoomRadio" id="zoomRadio{index}" class="zoom-radio">
|
|
<label for="zoomRadio{index}" class="zoom-img-container">
|
|
'''
|
|
|
|
# Check if the pic is an image or video
|
|
if pic['type'] == "video":
|
|
img_html += f'<video data-sampleimg="true" {playback} muted playsinline><source src="{image_url}" type="video/mp4"></video>'
|
|
meta_button = False
|
|
else:
|
|
img_html += f'<img data-sampleimg="true" src="{image_url}">'
|
|
|
|
img_html += '''
|
|
</label>
|
|
<label for="resetZoom" class="zoom-overlay"></label>
|
|
'''
|
|
|
|
if meta_button:
|
|
img_html += f'''
|
|
<div class="civitai_txt2img" style="margin-top:30px;margin-bottom:30px;">
|
|
<label onclick='sendImgUrl("{escape(image_url)}")' class="civitai-txt2img-btn" style="max-width:fit-content;cursor:pointer;">Send to txt2img</label>
|
|
</div></div>
|
|
'''
|
|
else:
|
|
img_html += '</div>'
|
|
|
|
if meta:
|
|
img_html += '<div style="margin:1em 0em 1em 1em;text-align:left;line-height:1.5em;" id="image_info"><dl>'
|
|
# Define the preferred order of keys and convert them to lowercase
|
|
preferred_order = ["prompt", "negativePrompt", "seed", "Size", "Model", "clipSkip", "sampler", "steps", "cfgScale"]
|
|
preferred_order_lower = [key.lower() for key in preferred_order]
|
|
# Loop through the keys in the preferred order and add them to the HTML
|
|
for key in preferred_order:
|
|
if key in meta:
|
|
value = meta[key]
|
|
img_html += f'<dt>{escape(str(key).capitalize())}</dt><dd>{escape(str(value))}</dd>'
|
|
# Check if there are remaining keys in meta
|
|
remaining_keys = [key for key in meta if key.lower() not in preferred_order_lower]
|
|
|
|
# Add the rest
|
|
if remaining_keys:
|
|
img_html += f"""
|
|
<div class="tabs">
|
|
<div class="tab">
|
|
<input type="checkbox" class="accordionCheckbox" id="chck{index}">
|
|
<label class="tab-label" for="chck{index}">More details...</label>
|
|
<div class="tab-content">
|
|
"""
|
|
for key in remaining_keys:
|
|
value = meta[key]
|
|
img_html += f'<dt>{escape(str(key).capitalize())}</dt><dd>{escape(str(value))}</dd>'
|
|
img_html = img_html + '</div></div></div>'
|
|
|
|
img_html += '</dl></div>'
|
|
|
|
img_html = img_html + '</div>'
|
|
img_html = img_html + '</div>'
|
|
tags_html = ''.join([f'<span class="civitai-tag">{escape(str(tag))}</span>' for tag in tags])
|
|
def perms_svg(color):
|
|
return f'<span style="display:inline-block;vertical-align:middle;">'\
|
|
f'<svg width="15" height="15" viewBox="0 1.5 24 24" stroke-width="4" stroke-linecap="round" stroke="{color}">'
|
|
allow_svg = f'{perms_svg("lime")}<path d="M5 12l5 5l10 -10"></path></svg></span>'
|
|
deny_svg = f'{perms_svg("red")}<path d="M18 6l-12 12"></path><path d="M6 6l12 12"></path></svg></span>'
|
|
perms_html= '<p style="line-height: 2; font-weight: bold;">'\
|
|
f'{allow_svg if item.get("allowNoCredit") else deny_svg} Use the model without crediting the creator<br/>'\
|
|
f'{allow_svg if item.get("allowCommercialUse") == "Image" else deny_svg} Sell images they generate<br/>'\
|
|
f'{allow_svg if item.get("allowCommercialUse") == "Rent" else deny_svg} Run on services that generate images for money<br/>'\
|
|
f'{allow_svg if item.get("allowCommercialUse") == "RentCivit" else deny_svg} Run on Civitai<br/>'\
|
|
f'{allow_svg if item.get("allowCommercialUse") == "Sell" else deny_svg} Sell this model or merges using this model<br/>'\
|
|
f'{allow_svg if item.get("allowDerivatives") else deny_svg} Share merges using this model<br/>'\
|
|
f'{allow_svg if item.get("allowDifferentLicense") else deny_svg} Have different permissions when sharing merges'\
|
|
'</p>'
|
|
output_html = f'''
|
|
<div class="model-block">
|
|
<h2><a href={model_main_url} target="_blank" id="model_header">{escape(str(model_name))}</a></h2>
|
|
<h3 class="model-uploader">Uploaded by <a href="https://civitai.com/user/{escape(str(model_uploader))}" target="_blank">{escape(str(model_uploader))}</a>{uploader_avatar}</h3>
|
|
<div class="civitai-version-info" style="display:flex; flex-wrap:wrap; justify-content:space-between;">
|
|
<dl id="info_block">
|
|
<dt>Version</dt>
|
|
<dd>{escape(str(model_version))}</dd>
|
|
<dt>Base Model</dt>
|
|
<dd>{escape(str(output_basemodel))}</dd>
|
|
<dt>CivitAI Tags</dt>
|
|
<dd>
|
|
<div class="civitai-tags-container">
|
|
{tags_html}
|
|
</div>
|
|
</dd>
|
|
<dt>Download Link</dt>
|
|
<dd><a href={model_url} target="_blank">{model_url}</a></dd>
|
|
</dl>
|
|
<div style="align-self:center; min-width:320px;">
|
|
<div>
|
|
{perms_html}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div class="model-description">
|
|
<h2>Description</h2>
|
|
{model_desc}
|
|
</div>
|
|
</div>
|
|
<div align=center>{img_html}</div>
|
|
'''
|
|
|
|
default_file = file_list[0] if file_list else None
|
|
|
|
folder_location = "None"
|
|
default_subfolder = "None"
|
|
sub_folders = ["None"]
|
|
|
|
for root, dirs, files in os.walk(model_folder):
|
|
for filename in files:
|
|
if filename.endswith('.json'):
|
|
json_file_path = os.path.join(root, filename)
|
|
with open(json_file_path, 'r') as f:
|
|
try:
|
|
data = json.load(f)
|
|
sha256 = data.get('sha256')
|
|
if sha256:
|
|
sha256 = sha256.upper()
|
|
if sha256 == sha256_value:
|
|
folder_location = root
|
|
BtnDownInt = False
|
|
BtnDel = True
|
|
|
|
break
|
|
except Exception as e:
|
|
print(f"{gl.print} Error decoding JSON: {str(e)}")
|
|
else:
|
|
for filename in files:
|
|
if filename == model_filename or filename == cleaned_name(model_filename):
|
|
folder_location = root
|
|
BtnDownInt = False
|
|
BtnDel = True
|
|
break
|
|
|
|
if folder_location != "None":
|
|
break
|
|
|
|
insert_sub = getattr(opts, "insert_sub", True)
|
|
dot_subfolders = getattr(opts, "dot_subfolders", True)
|
|
|
|
try:
|
|
sub_folders = ["None"]
|
|
for root, dirs, _ in os.walk(model_folder):
|
|
if dot_subfolders:
|
|
dirs = [d for d in dirs if not d.startswith('.')]
|
|
dirs = [d for d in dirs if not any(part.startswith('.') for part in os.path.join(root, d).split(os.sep))]
|
|
for d in dirs:
|
|
sub_folder = os.path.relpath(os.path.join(root, d), model_folder)
|
|
if sub_folder:
|
|
sub_folders.append(f'{os.sep}{sub_folder}')
|
|
|
|
sub_folders.remove("None")
|
|
sub_folders = sorted(sub_folders, key=lambda x: (x.lower(), x))
|
|
sub_folders.insert(0, "None")
|
|
sub_opt1 = os.path.join(os.sep, cleaned_name(model_uploader))
|
|
sub_opt2 = os.path.join(os.sep, cleaned_name(model_name))
|
|
sub_opt3 = os.path.join(os.sep, cleaned_name(model_name), cleaned_name(model_version))
|
|
if insert_sub:
|
|
sub_folders.insert(1, sub_opt1)
|
|
sub_folders.insert(2, sub_opt2)
|
|
sub_folders.insert(3, sub_opt3)
|
|
|
|
list = set()
|
|
sub_folders = [x for x in sub_folders if not (x in list or list.add(x))]
|
|
except:
|
|
sub_folders = ["None"]
|
|
|
|
default_sub = sub_folder_value(content_type, desc)
|
|
if default_sub == f"{os.sep}Author Name":
|
|
default_sub = sub_opt1
|
|
elif default_sub == f"{os.sep}Model Name":
|
|
default_sub = sub_opt2
|
|
elif default_sub == f"{os.sep}Model Name{os.sep}Version Name":
|
|
default_sub = sub_opt3
|
|
|
|
if folder_location == "None":
|
|
folder_location = model_folder
|
|
if default_sub != "None":
|
|
folder_path = folder_location + default_sub
|
|
else:
|
|
folder_path = folder_location
|
|
else:
|
|
folder_path = folder_location
|
|
relative_path = os.path.relpath(folder_location, model_folder)
|
|
default_subfolder = f'{os.sep}{relative_path}' if relative_path != "." else default_sub if BtnDel == False else "None"
|
|
if gl.isDownloading:
|
|
item = gl.download_queue[0]
|
|
if model_name == item['model_name']:
|
|
BtnDel = False
|
|
BtnDownTxt = "Download model"
|
|
if len(gl.download_queue) > 0:
|
|
BtnDownTxt = "Add to queue"
|
|
for item in gl.download_queue:
|
|
if item['version_name'] == model_version:
|
|
BtnDownInt = False
|
|
break
|
|
|
|
return (
|
|
gr.HTML.update(value=output_html), # Preview HTML
|
|
gr.Textbox.update(value=output_training, interactive=True), # Trained Tags
|
|
gr.Textbox.update(value=output_basemodel), # Base Model Number
|
|
gr.Button.update(visible=False if BtnDel else True, interactive=BtnDownInt, value=BtnDownTxt), # Download Button
|
|
gr.Button.update(interactive=BtnImage), # Images Button
|
|
gr.Button.update(visible=BtnDel, interactive=BtnDel), # Delete Button
|
|
gr.Dropdown.update(choices=file_list, value=default_file, interactive=True), # File List
|
|
gr.Textbox.update(value=cleaned_name(model_filename), interactive=True), # Model File Name
|
|
gr.Textbox.update(value=dl_url), # Download URL
|
|
gr.Textbox.update(value=model_id), # Model ID
|
|
gr.Textbox.update(value=sha256_value), # SHA256
|
|
gr.Textbox.update(interactive=True, value=folder_path if model_name else None), # Install Path
|
|
gr.Dropdown.update(choices=sub_folders, value=default_subfolder, interactive=True) # Sub Folder List
|
|
)
|
|
else:
|
|
return (
|
|
gr.HTML.update(value=None), # Preview HTML
|
|
gr.Textbox.update(value=None, interactive=False), # Trained Tags
|
|
gr.Textbox.update(value=''), # Base Model Number
|
|
gr.Button.update(visible=False if BtnDel else True, value="Download model"), # Download Button
|
|
gr.Button.update(interactive=False), # Images Button
|
|
gr.Button.update(visible=BtnDel, interactive=BtnDel), # Delete Button
|
|
gr.Dropdown.update(choices=None, value=None, interactive=False), # File List
|
|
gr.Textbox.update(value=None, interactive=False), # Model File Name
|
|
gr.Textbox.update(value=None), # Download URL
|
|
gr.Textbox.update(value=None), # Model ID
|
|
gr.Textbox.update(value=None), # SHA256
|
|
gr.Textbox.update(interactive=False, value=None), # Install Path
|
|
gr.Dropdown.update(choices=None, value=None, interactive=False) # Sub Folder List
|
|
)
|
|
|
|
def sub_folder_value(content_type, desc=None):
|
|
use_LORA = getattr(opts, "use_LORA", False)
|
|
if content_type in ["LORA", "LoCon"] and use_LORA:
|
|
folder = getattr(opts, "LORA_LoCon_subfolder", "None")
|
|
elif content_type == "Upscaler":
|
|
for upscale_type in ["SWINIR", "REALESRGAN", "GFPGAN", "BSRGAN"]:
|
|
if upscale_type in desc:
|
|
folder = getattr(opts, f"{upscale_type}_subfolder", "None")
|
|
folder = getattr(opts, "ESRGAN_subfolder", "None")
|
|
else:
|
|
folder = getattr(opts, f"{content_type}_subfolder", "None")
|
|
if folder == None:
|
|
return "None"
|
|
return folder
|
|
|
|
def update_file_info(model_name, model_version, file_metadata):
|
|
file_list = []
|
|
is_LORA = False
|
|
embed_check = False
|
|
if model_version and "[Installed]" in model_version:
|
|
model_version = model_version.replace(" [Installed]", "")
|
|
if model_name and model_version:
|
|
for item in gl.json_data['items']:
|
|
if item['name'] == model_name:
|
|
content_type = item['type']
|
|
if content_type == "LORA":
|
|
is_LORA = True
|
|
desc = item['description']
|
|
for model in item['modelVersions']:
|
|
if model['name'] == model_version:
|
|
for file in model['files']:
|
|
size = file['metadata'].get('size', 'Unknown')
|
|
format = file['metadata'].get('format', 'Unknown')
|
|
unique_file_name = f"{size} {format}"
|
|
file_list.append(unique_file_name)
|
|
pass
|
|
|
|
if is_LORA and file_list:
|
|
extracted_formats = [file.split(' ')[1] for file in file_list]
|
|
if "SafeTensor" in extracted_formats and "PickleTensor" in extracted_formats:
|
|
embed_check = True
|
|
|
|
for file in model['files']:
|
|
model_id = item['id']
|
|
file_name = file.get('name', 'Unknown')
|
|
sha256 = file['hashes'].get('SHA256', 'Unknown')
|
|
metadata = file.get('metadata', {})
|
|
file_size = metadata.get('size', 'Unknown')
|
|
file_format = metadata.get('format', 'Unknown')
|
|
file_fp = metadata.get('fp', 'Unknown')
|
|
sizeKB = file.get('sizeKB', 0)
|
|
sizeB = sizeKB * 1024
|
|
filesize = _download.convert_size(sizeB)
|
|
|
|
if f"{file_size} {file_format} {file_fp} ({filesize})" == file_metadata:
|
|
installed = False
|
|
folder_location = "None"
|
|
model_folder = os.path.join(contenttype_folder(content_type, desc))
|
|
if embed_check and file_format == "PickleTensor":
|
|
if sizeKB <= 100:
|
|
model_folder = os.path.join(contenttype_folder("TextualInversion"))
|
|
dl_url = file['downloadUrl']
|
|
gl.json_info = item
|
|
for root, _, files in os.walk(model_folder):
|
|
if file_name in files:
|
|
installed = True
|
|
folder_location = root
|
|
break
|
|
|
|
if not installed:
|
|
for root, _, files in os.walk(model_folder):
|
|
for filename in files:
|
|
if filename.endswith('.json'):
|
|
with open(os.path.join(root, filename), 'r') as f:
|
|
try:
|
|
data = json.load(f)
|
|
if "sha256" in data:
|
|
if data.get('sha256').upper() == sha256:
|
|
folder_location = root
|
|
installed = True
|
|
break
|
|
except Exception as e:
|
|
print(f"{gl.print} Error decoding JSON: {str(e)}")
|
|
default_sub = sub_folder_value(content_type, desc)
|
|
if folder_location == "None":
|
|
folder_location = model_folder
|
|
if default_sub != "None":
|
|
folder_path = folder_location + default_sub
|
|
else:
|
|
folder_path = folder_location
|
|
else:
|
|
folder_path = folder_location
|
|
relative_path = os.path.relpath(folder_location, model_folder)
|
|
default_subfolder = f'{os.sep}{relative_path}' if relative_path != "." else default_sub if installed == False else "None"
|
|
BtnDownInt = not installed
|
|
BtnDownTxt = "Download model"
|
|
if len(gl.download_queue) > 0:
|
|
BtnDownTxt = "Add to queue"
|
|
for item in gl.download_queue:
|
|
if item['version_name'] == model_version:
|
|
BtnDownInt = False
|
|
break
|
|
|
|
return (
|
|
gr.Textbox.update(value=cleaned_name(file['name']), interactive=True), # Model File Name Textbox
|
|
gr.Textbox.update(value=dl_url), # Download URL Textbox
|
|
gr.Textbox.update(value=model_id), # Model ID Textbox
|
|
gr.Textbox.update(value=sha256), # sha256 textbox
|
|
gr.Button.update(interactive=BtnDownInt, visible=False if installed else True, value=BtnDownTxt), # Download Button
|
|
gr.Button.update(interactive=True if installed else False, visible=True if installed else False), # Delete Button
|
|
gr.Textbox.update(interactive=True, value=folder_path if model_name else None), # Install Path
|
|
gr.Dropdown.update(value=default_subfolder, interactive=True) # Sub Folder List
|
|
)
|
|
|
|
return (
|
|
gr.Textbox.update(value=None, interactive=False), # Model File Name Textbox
|
|
gr.Textbox.update(value=None), # Download URL Textbox
|
|
gr.Textbox.update(value=None), # Model ID Textbox
|
|
gr.Textbox.update(value=None), # sha256 textbox
|
|
gr.Button.update(interactive=False, visible=True), # Download Button
|
|
gr.Button.update(interactive=False, visible=False), # Delete Button
|
|
gr.Textbox.update(interactive=False, value=None), # Install Path
|
|
gr.Dropdown.update(choices=None, value=None, interactive=False) # Sub Folder List
|
|
)
|
|
|
|
def request_civit_api(api_url=None):
|
|
api_key = getattr(opts, "custom_api_key", "")
|
|
if not api_key:
|
|
api_key = "eaee11648ef4c72efb2333d5ebc68b98"
|
|
try:
|
|
user_agent = UserAgent().chrome
|
|
except ImportError:
|
|
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
|
|
headers = {
|
|
'User-Agent': user_agent,
|
|
'Sec-Ch-Ua': '"Brave";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
|
|
'Sec-Ch-Ua-Mobile': '?0',
|
|
'Sec-Ch-Ua-Platform': '"Windows"',
|
|
'Sec-Fetch-Dest': 'document',
|
|
'Sec-Fetch-Mode': 'navigate',
|
|
'Sec-Fetch-Site': 'none',
|
|
'Sec-Fetch-User': '?1',
|
|
'Sec-Gpc': '1',
|
|
'Upgrade-Insecure-Requests': '1',
|
|
'Authorization': f'Bearer {api_key}'
|
|
}
|
|
try:
|
|
response = requests.get(api_url, headers=headers, timeout=(10, 30))
|
|
response.raise_for_status()
|
|
except requests.exceptions.RequestException as e:
|
|
print(f"{gl.print} Error: {e}")
|
|
return "timeout"
|
|
else:
|
|
response.encoding = "utf-8"
|
|
try:
|
|
data = json.loads(response.text)
|
|
except json.JSONDecodeError:
|
|
print(f"{gl.print} The CivitAI servers are currently offline. Please try again later.")
|
|
return "timeout"
|
|
return data |