Spaces:
Runtime error
Runtime error
| import json | |
| import os | |
| import gradio as gr | |
| # from modules import errors | |
| from .ui_components import ToolButton | |
| class UiLoadsave: | |
| """allows saving and restoring default values for gradio components""" | |
| def __init__(self, filename): | |
| self.filename = filename | |
| self.ui_settings = {} | |
| self.component_mapping = {} | |
| self.error_loading = False | |
| self.finalized_ui = False | |
| self.ui_defaults_view = None | |
| self.ui_defaults_apply = None | |
| self.ui_defaults_review = None | |
| try: | |
| if os.path.exists(self.filename): | |
| self.ui_settings = self.read_from_file() | |
| except Exception as e: | |
| self.error_loading = True | |
| print(e, "loading settings") | |
| def add_component(self, path, x): | |
| """adds component to the registry of tracked components""" | |
| assert not self.finalized_ui | |
| # print(f"Type: {type(x)}") | |
| # print(f"value: {getattr(x, 'value', None)}") | |
| def apply_field(obj, field, condition=None, init_field=None): | |
| key = f"{path}/{field}" | |
| if getattr(obj, "custom_script_source", None) is not None: | |
| key = f"customscript/{obj.custom_script_source}/{key}" | |
| if getattr(obj, "do_not_save_to_config", False): | |
| return | |
| saved_value = self.ui_settings.get(key, None) | |
| if saved_value is None: | |
| self.ui_settings[key] = getattr(obj, field) | |
| elif condition and not condition(saved_value): | |
| pass | |
| else: | |
| setattr(obj, field, saved_value) | |
| if init_field is not None: | |
| init_field(saved_value) | |
| if field == "value" and key not in self.component_mapping: | |
| self.component_mapping[key] = x | |
| if ( | |
| type(x) | |
| in [ | |
| gr.Slider, | |
| gr.Radio, | |
| gr.Checkbox, | |
| gr.Textbox, | |
| gr.Number, | |
| gr.Dropdown, | |
| ToolButton, | |
| gr.Button, | |
| gr.TextArea, | |
| ] | |
| and x.visible | |
| ): | |
| apply_field(x, "visible") | |
| if type(x) == gr.Slider: | |
| apply_field(x, "value") | |
| apply_field(x, "minimum") | |
| apply_field(x, "maximum") | |
| apply_field(x, "step") | |
| # if type(x) == gr.File: | |
| # print(f"{dir(x)}") | |
| # apply_field(x, 'value') | |
| # apply_field(x, 'type') | |
| # if type(x) == gr.Audio: | |
| # print(f"{dir(x)}") | |
| # apply_field(x, 'value') | |
| # apply_field(x, 'type') | |
| # apply_field(x, 'source') | |
| if type(x) == gr.Radio: | |
| apply_field(x, "value", lambda val: val in x.choices) | |
| if type(x) == gr.Checkbox: | |
| apply_field(x, "value") | |
| if type(x) == gr.Textbox or type(x) == gr.TextArea: | |
| apply_field(x, "value") | |
| if type(x) == gr.Number: | |
| apply_field(x, "value") | |
| if type(x) == gr.Dropdown: | |
| def check_dropdown(val): | |
| if getattr(x, "multiselect", False): | |
| return all(value in x.choices for value in val) | |
| else: | |
| return val in x.choices | |
| apply_field(x, "value", check_dropdown, getattr(x, "init_field", None)) | |
| def check_tab_id(tab_id): | |
| tab_items = list(filter(lambda e: isinstance(e, gr.TabItem), x.children)) | |
| if type(tab_id) == str: | |
| tab_ids = [t.id for t in tab_items] | |
| return tab_id in tab_ids | |
| elif type(tab_id) == int: | |
| return 0 <= tab_id < len(tab_items) | |
| else: | |
| return False | |
| if type(x) == gr.Tabs: | |
| apply_field(x, "selected", check_tab_id) | |
| def add_block(self, x, path=""): | |
| """adds all components inside a gradio block x to the registry of tracked components""" | |
| if hasattr(x, "children"): | |
| if isinstance(x, gr.Tabs) and x.elem_id is not None: | |
| # Tabs element can't have a label, have to use elem_id instead | |
| self.add_component(f"{path}/Tabs@{x.elem_id}", x) | |
| for c in x.children: | |
| self.add_block(c, path) | |
| elif x.label is not None: | |
| self.add_component(f"{path}/{x.label}", x) | |
| elif isinstance(x, gr.Button) and x.value is not None: | |
| self.add_component(f"{path}/{x.value}", x) | |
| else: | |
| pass | |
| # print("Unknown type: ", type(x)) | |
| # print(f"val: {x.value}") | |
| def read_from_file(self): | |
| with open(self.filename, "r", encoding="utf8") as file: | |
| return json.load(file) | |
| def write_to_file(self, current_ui_settings): | |
| with open(self.filename, "w", encoding="utf8") as file: | |
| json.dump(current_ui_settings, file, indent=4) | |
| def dump_defaults(self): | |
| """saves default values to a file unless the file is present and there was an error loading default values at start""" | |
| if self.error_loading and os.path.exists(self.filename): | |
| return | |
| self.write_to_file(self.ui_settings) | |
| def iter_changes(self, current_ui_settings, values): | |
| """ | |
| given a dictionary with defaults from a file and current values from gradio elements, returns | |
| an iterator over tuples of values that are not the same between the file and the current; | |
| tuple contents are: path, old value, new value | |
| """ | |
| for (path, component), new_value in zip(self.component_mapping.items(), values): | |
| old_value = current_ui_settings.get(path) | |
| choices = getattr(component, "choices", None) | |
| if isinstance(new_value, int) and choices: | |
| if new_value >= len(choices): | |
| continue | |
| new_value = choices[new_value] | |
| if new_value == old_value: | |
| continue | |
| if old_value is None and new_value == "" or new_value == []: | |
| continue | |
| yield path, old_value, new_value | |
| def ui_view(self, *values): | |
| text = [ | |
| "<table><thead><tr><th>Path</th><th>Old value</th><th>New value</th></thead><tbody>" | |
| ] | |
| for path, old_value, new_value in self.iter_changes(self.read_from_file(), values): | |
| if old_value is None: | |
| old_value = "<span class='ui-defaults-none'>None</span>" | |
| text.append(f"<tr><td>{path}</td><td>{old_value}</td><td>{new_value}</td></tr>") | |
| if len(text) == 1: | |
| text.append("<tr><td colspan=3>No changes</td></tr>") | |
| text.append("</tbody>") | |
| return "".join(text) | |
| def ui_apply(self, *values): | |
| num_changed = 0 | |
| current_ui_settings = self.read_from_file() | |
| for path, _, new_value in self.iter_changes(current_ui_settings.copy(), values): | |
| num_changed += 1 | |
| current_ui_settings[path] = new_value | |
| if num_changed == 0: | |
| return "No changes." | |
| self.write_to_file(current_ui_settings) | |
| return f"Wrote {num_changed} changes." | |
| def create_ui(self): | |
| """creates ui elements for editing defaults UI, without adding any logic to them""" | |
| gr.HTML( | |
| f"This page allows you to change default values in UI elements on other tabs.<br />" | |
| f"Make your changes, press 'View changes' to review the changed default values,<br />" | |
| f"then press 'Apply' to write them to {self.filename}.<br />" | |
| f"New defaults will apply after you restart the UI.<br />" | |
| f"You can edit the gradio_options.json file, or delete it to reset defaults.<br />" | |
| ) | |
| with gr.Row(): | |
| self.ui_defaults_view = gr.Button( | |
| value="View changes", elem_id="ui_defaults_view", variant="secondary" | |
| ) | |
| self.ui_defaults_apply = gr.Button( | |
| value="Apply", elem_id="ui_defaults_apply", variant="primary" | |
| ) | |
| self.ui_defaults_review = gr.HTML("") | |
| def setup_ui(self): | |
| """adds logic to elements created with create_ui; all add_block class must be made before this""" | |
| assert not self.finalized_ui | |
| self.finalized_ui = True | |
| self.ui_defaults_view.click( | |
| fn=self.ui_view, | |
| inputs=list(self.component_mapping.values()), | |
| outputs=[self.ui_defaults_review], | |
| ) | |
| self.ui_defaults_apply.click( | |
| fn=self.ui_apply, | |
| inputs=list(self.component_mapping.values()), | |
| outputs=[self.ui_defaults_review], | |
| ) | |
| # print(f"UI default component+path mapping: {self.component_mapping}") | |