|
import json |
|
import sys |
|
from dataclasses import dataclass |
|
|
|
import gradio as gr |
|
|
|
from modules import errors |
|
from modules.shared_cmd_options import cmd_opts |
|
|
|
|
|
class OptionInfo: |
|
def __init__(self, default=None, label="", component=None, component_args=None, onchange=None, section=None, refresh=None, comment_before='', comment_after='', infotext=None, restrict_api=False, category_id=None): |
|
self.default = default |
|
self.label = label |
|
self.component = component |
|
self.component_args = component_args |
|
self.onchange = onchange |
|
self.section = section |
|
self.category_id = category_id |
|
self.refresh = refresh |
|
self.do_not_save = False |
|
|
|
self.comment_before = comment_before |
|
"""HTML text that will be added after label in UI""" |
|
|
|
self.comment_after = comment_after |
|
"""HTML text that will be added before label in UI""" |
|
|
|
self.infotext = infotext |
|
|
|
self.restrict_api = restrict_api |
|
"""If True, the setting will not be accessible via API""" |
|
|
|
def link(self, label, url): |
|
self.comment_before += f"[<a href='{url}' target='_blank'>{label}</a>]" |
|
return self |
|
|
|
def js(self, label, js_func): |
|
self.comment_before += f"[<a onclick='{js_func}(); return false'>{label}</a>]" |
|
return self |
|
|
|
def info(self, info): |
|
self.comment_after += f"<span class='info'>({info})</span>" |
|
return self |
|
|
|
def html(self, html): |
|
self.comment_after += html |
|
return self |
|
|
|
def needs_restart(self): |
|
self.comment_after += " <span class='info'>(requires restart)</span>" |
|
return self |
|
|
|
def needs_reload_ui(self): |
|
self.comment_after += " <span class='info'>(requires Reload UI)</span>" |
|
return self |
|
|
|
|
|
class OptionHTML(OptionInfo): |
|
def __init__(self, text): |
|
super().__init__(str(text).strip(), label='', component=lambda **kwargs: gr.HTML(elem_classes="settings-info", **kwargs)) |
|
|
|
self.do_not_save = True |
|
|
|
|
|
def options_section(section_identifier, options_dict): |
|
for v in options_dict.values(): |
|
if len(section_identifier) == 2: |
|
v.section = section_identifier |
|
elif len(section_identifier) == 3: |
|
v.section = section_identifier[0:2] |
|
v.category_id = section_identifier[2] |
|
|
|
return options_dict |
|
|
|
|
|
options_builtin_fields = {"data_labels", "data", "restricted_opts", "typemap"} |
|
|
|
|
|
class Options: |
|
typemap = {int: float} |
|
|
|
def __init__(self, data_labels: dict[str, OptionInfo], restricted_opts): |
|
self.data_labels = data_labels |
|
self.data = {k: v.default for k, v in self.data_labels.items() if not v.do_not_save} |
|
self.restricted_opts = restricted_opts |
|
|
|
def __setattr__(self, key, value): |
|
if key in options_builtin_fields: |
|
return super(Options, self).__setattr__(key, value) |
|
|
|
if self.data is not None: |
|
if key in self.data or key in self.data_labels: |
|
assert not cmd_opts.freeze_settings, "changing settings is disabled" |
|
|
|
info = self.data_labels.get(key, None) |
|
if info.do_not_save: |
|
return |
|
|
|
comp_args = info.component_args if info else None |
|
if isinstance(comp_args, dict) and comp_args.get('visible', True) is False: |
|
raise RuntimeError(f"not possible to set {key} because it is restricted") |
|
|
|
if cmd_opts.hide_ui_dir_config and key in self.restricted_opts: |
|
raise RuntimeError(f"not possible to set {key} because it is restricted") |
|
|
|
self.data[key] = value |
|
return |
|
|
|
return super(Options, self).__setattr__(key, value) |
|
|
|
def __getattr__(self, item): |
|
if item in options_builtin_fields: |
|
return super(Options, self).__getattribute__(item) |
|
|
|
if self.data is not None: |
|
if item in self.data: |
|
return self.data[item] |
|
|
|
if item in self.data_labels: |
|
return self.data_labels[item].default |
|
|
|
return super(Options, self).__getattribute__(item) |
|
|
|
def set(self, key, value, is_api=False, run_callbacks=True): |
|
"""sets an option and calls its onchange callback, returning True if the option changed and False otherwise""" |
|
|
|
oldval = self.data.get(key, None) |
|
if oldval == value: |
|
return False |
|
|
|
option = self.data_labels[key] |
|
if option.do_not_save: |
|
return False |
|
|
|
if is_api and option.restrict_api: |
|
return False |
|
|
|
try: |
|
setattr(self, key, value) |
|
except RuntimeError: |
|
return False |
|
|
|
if run_callbacks and option.onchange is not None: |
|
try: |
|
option.onchange() |
|
except Exception as e: |
|
errors.display(e, f"changing setting {key} to {value}") |
|
setattr(self, key, oldval) |
|
return False |
|
|
|
return True |
|
|
|
def get_default(self, key): |
|
"""returns the default value for the key""" |
|
|
|
data_label = self.data_labels.get(key) |
|
if data_label is None: |
|
return None |
|
|
|
return data_label.default |
|
|
|
def save(self, filename): |
|
assert not cmd_opts.freeze_settings, "saving settings is disabled" |
|
|
|
with open(filename, "w", encoding="utf8") as file: |
|
json.dump(self.data, file, indent=4, ensure_ascii=False) |
|
|
|
def same_type(self, x, y): |
|
if x is None or y is None: |
|
return True |
|
|
|
type_x = self.typemap.get(type(x), type(x)) |
|
type_y = self.typemap.get(type(y), type(y)) |
|
|
|
return type_x == type_y |
|
|
|
def load(self, filename): |
|
with open(filename, "r", encoding="utf8") as file: |
|
self.data = json.load(file) |
|
|
|
|
|
if self.data.get('sd_vae_as_default') is not None and self.data.get('sd_vae_overrides_per_model_preferences') is None: |
|
self.data['sd_vae_overrides_per_model_preferences'] = not self.data.get('sd_vae_as_default') |
|
|
|
|
|
if self.data.get('quicksettings') is not None and self.data.get('quicksettings_list') is None: |
|
self.data['quicksettings_list'] = [i.strip() for i in self.data.get('quicksettings').split(',')] |
|
|
|
|
|
if isinstance(self.data.get('ui_reorder'), str) and self.data.get('ui_reorder') and "ui_reorder_list" not in self.data: |
|
self.data['ui_reorder_list'] = [i.strip() for i in self.data.get('ui_reorder').split(',')] |
|
|
|
bad_settings = 0 |
|
for k, v in self.data.items(): |
|
info = self.data_labels.get(k, None) |
|
if info is not None and not self.same_type(info.default, v): |
|
print(f"Warning: bad setting value: {k}: {v} ({type(v).__name__}; expected {type(info.default).__name__})", file=sys.stderr) |
|
bad_settings += 1 |
|
|
|
if bad_settings > 0: |
|
print(f"The program is likely to not work with bad settings.\nSettings file: {filename}\nEither fix the file, or delete it and restart.", file=sys.stderr) |
|
|
|
def onchange(self, key, func, call=True): |
|
item = self.data_labels.get(key) |
|
item.onchange = func |
|
|
|
if call: |
|
func() |
|
|
|
def dumpjson(self): |
|
d = {k: self.data.get(k, v.default) for k, v in self.data_labels.items()} |
|
d["_comments_before"] = {k: v.comment_before for k, v in self.data_labels.items() if v.comment_before is not None} |
|
d["_comments_after"] = {k: v.comment_after for k, v in self.data_labels.items() if v.comment_after is not None} |
|
|
|
item_categories = {} |
|
for item in self.data_labels.values(): |
|
category = categories.mapping.get(item.category_id) |
|
category = "Uncategorized" if category is None else category.label |
|
if category not in item_categories: |
|
item_categories[category] = item.section[1] |
|
|
|
|
|
d["_categories"] = [[v, k] for k, v in item_categories.items()] + [["Defaults", "Other"]] |
|
|
|
return json.dumps(d) |
|
|
|
def add_option(self, key, info): |
|
self.data_labels[key] = info |
|
if key not in self.data and not info.do_not_save: |
|
self.data[key] = info.default |
|
|
|
def reorder(self): |
|
"""Reorder settings so that: |
|
- all items related to section always go together |
|
- all sections belonging to a category go together |
|
- sections inside a category are ordered alphabetically |
|
- categories are ordered by creation order |
|
|
|
Category is a superset of sections: for category "postprocessing" there could be multiple sections: "face restoration", "upscaling". |
|
|
|
This function also changes items' category_id so that all items belonging to a section have the same category_id. |
|
""" |
|
|
|
category_ids = {} |
|
section_categories = {} |
|
|
|
settings_items = self.data_labels.items() |
|
for _, item in settings_items: |
|
if item.section not in section_categories: |
|
section_categories[item.section] = item.category_id |
|
|
|
for _, item in settings_items: |
|
item.category_id = section_categories.get(item.section) |
|
|
|
for category_id in categories.mapping: |
|
if category_id not in category_ids: |
|
category_ids[category_id] = len(category_ids) |
|
|
|
def sort_key(x): |
|
item: OptionInfo = x[1] |
|
category_order = category_ids.get(item.category_id, len(category_ids)) |
|
section_order = item.section[1] |
|
|
|
return category_order, section_order |
|
|
|
self.data_labels = dict(sorted(settings_items, key=sort_key)) |
|
|
|
def cast_value(self, key, value): |
|
"""casts an arbitrary to the same type as this setting's value with key |
|
Example: cast_value("eta_noise_seed_delta", "12") -> returns 12 (an int rather than str) |
|
""" |
|
|
|
if value is None: |
|
return None |
|
|
|
default_value = self.data_labels[key].default |
|
if default_value is None: |
|
default_value = getattr(self, key, None) |
|
if default_value is None: |
|
return None |
|
|
|
expected_type = type(default_value) |
|
if expected_type == bool and value == "False": |
|
value = False |
|
else: |
|
value = expected_type(value) |
|
|
|
return value |
|
|
|
|
|
@dataclass |
|
class OptionsCategory: |
|
id: str |
|
label: str |
|
|
|
class OptionsCategories: |
|
def __init__(self): |
|
self.mapping = {} |
|
|
|
def register_category(self, category_id, label): |
|
if category_id in self.mapping: |
|
return category_id |
|
|
|
self.mapping[category_id] = OptionsCategory(category_id, label) |
|
|
|
|
|
categories = OptionsCategories() |
|
|
