fix wrong state handling

app.py

@@ -6,15 +6,6 @@ import torch
 import json
 from PIL import Image
 from diffusers import DiffusionPipeline
-from diffusers import (
-    DDPMScheduler,
-    DDIMScheduler,
-    PNDMScheduler,
-    LMSDiscreteScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    DPMSolverMultistepScheduler,
-)
 import threading
 import requests
 from flask import Flask, render_template_string
@@ -22,181 +13,175 @@ from gradio import Interface
 from diffusers import AutoencoderKL
 import pandas as pd 
 import base64
-from config import Config, init_config
+from config import *
+from helpers import *
 
-config = Config()
-
-def device_change(device):
+def device_change(device, config):
+    
+    config = set_config(config, 'device', device)
     
-    return config.set_config('device', device), config.assemble_code()
+    return config, str(config), assemble_code(config)
+
+def models_change(model, scheduler, config):
+
+    config = set_config(config, 'model', model)
 
-def models_change(model, scheduler):
-        
     use_safetensors = False
     
     # no model selected (because this is UI init run)
-    if type(model) != list and model is not None:
+    if type(model) != list and str(model) != 'None':
+        
+        use_safetensors = str(models[model]['use_safetensors'])
+        model_description = models[model]['description']
         
-        use_safetensors = str(config.model_configs[model]['use_safetensors'])
-
         # if no scheduler is selected, choose the default one for this model
         if scheduler == None:
             
-            scheduler = config.model_configs[model]['scheduler']
+            scheduler = models[model]['scheduler']
 
-    safety_checker_change(config.current["safety_checker"])
-    requires_safety_checker_change(config.current["requires_safety_checker"])
+    else:
 
-    return use_safetensors, scheduler, config.set_config('model', model), config.assemble_code()
+        model_description = 'Please select a model.'
+        
+    config["use_safetensors"] = str(use_safetensors)
+    config["scheduler"] = str(scheduler)
+    
+    # safety_checker_change(in_safety_checker.value, config)
+    # requires_safety_checker_change(in_requires_safety_checker.value, config)
 
-def data_type_change(data_type):
+    return model_description, use_safetensors, scheduler, config, str(config), assemble_code(config)
 
-    return config.set_config('data_type', data_type), config.assemble_code()
+def data_type_change(data_type, config):
 
-def get_data_type(str_data_type):
-    
-    if str_data_type == "bfloat16":
-        return torch.bfloat16 # BFloat16 is not supported on MPS as of 01/2024
-    else:
-        return torch.float16 # Half-precision weights, as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 will save GPU memory
+    config = set_config(config, 'data_type', data_type)
+
+    return config, str(config), assemble_code(config)
 
-def tensorfloat32_change(allow_tensorfloat32):  
+def tensorfloat32_change(allow_tensorfloat32, config):  
         
-    return config.set_config('allow_tensorfloat32', allow_tensorfloat32), config.assemble_code()
+    config = set_config(config, 'allow_tensorfloat32', allow_tensorfloat32)
+
+    return config, str(config), assemble_code(config)
 
-def inference_steps_change(inference_steps):
+def inference_steps_change(inference_steps, config):
     
-    return config.set_config('inference_steps', inference_steps), config.assemble_code()
+    config = set_config(config, 'inference_steps', inference_steps)
 
-def manual_seed_change(manual_seed):
-            
-    return config.set_config('manual_seed', manual_seed), config.assemble_code()
+    return config, str(config), assemble_code(config)
 
-def guidance_scale_change(guidance_scale):
+def manual_seed_change(manual_seed, config):
     
-    return config.set_config('guidance_scale', guidance_scale), config.assemble_code()
+    config = set_config(config, 'manual_seed', manual_seed)
 
-def prompt_change(prompt):
-    
-    return config.set_config('prompt', prompt), config.assemble_code()
+    return config, str(config), assemble_code(config)
 
-def negative_prompt_change(negative_prompt):
+def guidance_scale_change(guidance_scale, config):
+
+    config = set_config(config, 'guidance_scale', guidance_scale)
+
+    return config, str(config), assemble_code(config)
+
+def prompt_change(prompt, config):
     
-    return config.set_config('negative_prompt', negative_prompt), config.assemble_code()
+    config = set_config(config, 'prompt', prompt)
 
-def variant_change(variant):
+    return config, str(config), assemble_code(config)
+
+def negative_prompt_change(negative_prompt, config):
     
-    return config.set_config('variant', variant), config.assemble_code()
+    config = set_config(config, 'negative_prompt', negative_prompt)
     
-def safety_checker_change(safety_checker):
-        
-    return config.set_config('safety_checker', safety_checker), config.assemble_code()
+    return config, str(config), assemble_code(config)
 
-def requires_safety_checker_change(requires_safety_checker):
+def variant_change(variant, config):
     
-    return config.set_config('requires_safety_checker', requires_safety_checker), config.assemble_code()
+    config = set_config(config, 'variant', variant)
 
-def schedulers_change(scheduler):
+    return config, str(config), assemble_code(config)
     
-    return config.get_scheduler_description(scheduler), config.set_config('scheduler', scheduler), config.assemble_code()
-
-def get_tensorfloat32(allow_tensorfloat32):
+def safety_checker_change(safety_checker, config):
         
-    return True if str(allow_tensorfloat32).lower() == 'true' else False
+    config = set_config(config, 'safety_checker', safety_checker)
+
+    return config, str(config), assemble_code(config)
+
+def requires_safety_checker_change(requires_safety_checker, config):
+
+    config = set_config(config, 'requires_safety_checker', requires_safety_checker)
+
+    return config, str(config), assemble_code(config)
 
-def get_scheduler(scheduler, pipeline_config):
+def schedulers_change(scheduler, config):
     
-    if scheduler == "DDPMScheduler":
-        return DDPMScheduler.from_config(pipeline_config)
-    elif scheduler == "DDIMScheduler":
-        return DDIMScheduler.from_config(pipeline_config)
-    elif scheduler == "PNDMScheduler":
-        return PNDMScheduler.from_config(pipeline_config)
-    elif scheduler == "LMSDiscreteScheduler":
-        return LMSDiscreteScheduler.from_config(pipeline_config)
-    elif scheduler == "EulerAncestralDiscreteScheduler":
-        return EulerAncestralDiscreteScheduler.from_config(pipeline_config)
-    elif scheduler == "EulerDiscreteScheduler":
-        return EulerDiscreteScheduler.from_config(pipeline_config)
-    elif scheduler == "DPMSolverMultistepScheduler":
-        return DPMSolverMultistepScheduler.from_config(pipeline_config)
+    if str(scheduler) != 'None' and type(scheduler) != list:
+        
+        scheduler_description = schedulers[scheduler]
+        
     else:
-        return DPMSolverMultistepScheduler.from_config(pipeline_config)
-
-# get 
-# - initial configuration, 
-# - a list of available devices from the config file
-# - a list of available models from the config file
-# - a list of available schedulers from the config file
-# - a dict that contains code to for reproduction
+        scheduler_description = 'Please select a scheduler.'
+        
+    config = set_config(config, 'scheduler', scheduler)
 
-# pipeline
-def run_inference(progress=gr.Progress(track_tqdm=True)):
+    return scheduler_description, config, str(config), assemble_code(config)
+    
+def run_inference(config, config_history, progress=gr.Progress(track_tqdm=True)):
     
-    if config.current["model"] != None and config.current["scheduler"] != None:
+    # str_config = str_config.replace("'", '"').replace('None', 'null').replace('False', 'false')
+    # config = json.loads(str_config)
+
+    if str(config["model"]) != 'None' and str(config["scheduler"]) != 'None':
         
         progress((1,3), desc="Preparing pipeline initialization...")
         
-        torch.backends.cuda.matmul.allow_tf32 = config.current["allow_tensorfloat32"] # Use TensorFloat-32 as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 faster, but slightly less accurate computations
+        torch.backends.cuda.matmul.allow_tf32 = get_bool(config["allow_tensorfloat32"]) # Use TensorFloat-32 as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 faster, but slightly less accurate computations
         
         progress((2,3), desc="Initializing pipeline...")
-        
+                    
         pipeline = DiffusionPipeline.from_pretrained(
-            config.current["model"], 
-            use_safetensors = config.current["use_safetensors"], 
-            torch_dtype = get_data_type(config.current["data_type"]), 
-            variant = config.current["variant"]).to(config.current["device"])
+            config["model"], 
+            use_safetensors = get_bool(config["use_safetensors"]), 
+            torch_dtype = get_data_type(config["data_type"]), 
+            variant = get_variant(config["variant"])).to(config["device"])
         
-        if config.current["safety_checker"] is None or str(config.current["safety_checker"]).lower == 'false':
+        if str(config["safety_checker"]).lower() == 'false':
             pipeline.safety_checker = None 
 
-        pipeline.requires_safety_checker = config.current["requires_safety_checker"]
-                
-        pipeline.scheduler = get_scheduler(config.current["scheduler"], pipeline.scheduler.config)
+        pipeline.requires_safety_checker = get_bool(config["requires_safety_checker"])
+            
+        pipeline.scheduler = get_scheduler(config["scheduler"], pipeline.scheduler.config)
         
-        if config.current["manual_seed"] < 0 or config.current["manual_seed"] is None or config.current["manual_seed"] == '':
-            generator = torch.Generator(config.current["device"])
+        if config["manual_seed"] < 0 or config["manual_seed"] is None or config["manual_seed"] == '':
+            generator = torch.Generator(config["device"])
         else:
-            generator = torch.manual_seed(42) 
+            generator = torch.manual_seed(int(config["manual_seed"])) 
         
         progress((3,3), desc="Creating the result...")
 
         image = pipeline(
-            prompt = config.current["prompt"],
-            negative_prompt = config.current["negative_prompt"],
+            prompt = config["prompt"],
+            negative_prompt = config["negative_prompt"],
             generator = generator,
-            num_inference_steps = config.current["inference_steps"], 
-            guidance_scale = config.current["guidance_scale"]).images[0]
+            num_inference_steps = int(config["inference_steps"]), 
+            guidance_scale = float(config["guidance_scale"])).images[0]
         
-        config.history.append(config.current.copy())
+        config_history.append(config.copy())
 
-        return image, dict_list_to_markdown_table(config.history)
+        return image, dict_list_to_markdown_table(config_history), config_history
     
     else:
     
-        return "Please select a model AND a scheduler.", None
-
-def dict_list_to_markdown_table(config_history):
-
-    if not config_history:
-        return ""
+        return "Please select a model AND a scheduler.", None, config_history
 
-    headers = list(config_history[0].keys())
-    markdown_table = "| share | " + " | ".join(headers) + " |\n"
-    markdown_table += "| ---  | " + " | ".join(["---"] * len(headers)) + " |\n"
-
-    for index, config in enumerate(config_history):
-            
-        encoded_config = base64.b64encode(str(config).encode()).decode()
-        share_link = f'<a target="_blank" href="?config={encoded_config}">📎</a>'
-        markdown_table += f"| {share_link} | " + " | ".join(str(config.get(key, "")) for key in headers) + " |\n"
-
-    markdown_table = '<div style="overflow-x: auto;">\n\n' + markdown_table + '</div>'
-
-    return markdown_table
+appConfig = load_app_config()
+models = appConfig.get("models", {})
+schedulers = appConfig.get("schedulers", {})
+devices =  appConfig.get("devices", [])
 
 # interface
 with gr.Blocks() as demo:
+    
+    config = gr.State(value=get_initial_config())
+    config_history = gr.State(value=[])
         
     gr.Markdown('''## Text-2-Image Playground
                 <small>by <a target="_blank" href="https://www.linkedin.com/in/nickyreinert/">Nicky Reinert</a> | 
@@ -204,26 +189,25 @@ with gr.Blocks() as demo:
                 </small>''')
     gr.Markdown("### Device specific settings")
     with gr.Row():
-        in_devices = gr.Dropdown(label="Device:", value=config.current["device"], choices=config.devices, filterable=True, multiselect=False, allow_custom_value=True)
-        in_data_type = gr.Radio(label="Data Type:", value=config.current["data_type"], choices=["bfloat16", "float16"], info="`bfloat16` is not supported on MPS devices right now; Half-precision weights, will save GPU memory, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16")
-        in_allow_tensorfloat32 = gr.Radio(label="Allow TensorFloat32:", value=config.current["allow_tensorfloat32"], choices=[True, False], info="is not supported on MPS devices right now; use TensorFloat-32 is faster, but results in slightly less accurate computations, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ")
-        in_variant = gr.Radio(label="Variant:", value=config.current["variant"], choices=["fp16", None], info="Use half-precision weights will save GPU memory, not all models support that, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ")
+        in_devices = gr.Dropdown(label="Device:", value=config.value["device"], choices=devices, filterable=True, multiselect=False, allow_custom_value=True)
+        in_data_type = gr.Radio(label="Data Type:", value=config.value["data_type"], choices=["bfloat16", "float16"], info="`bfloat16` is not supported on MPS devices right now; Half-precision weights, will save GPU memory, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16")
+        in_allow_tensorfloat32 = gr.Radio(label="Allow TensorFloat32:", value=config.value["allow_tensorfloat32"], choices=["True", "False"], info="is not supported on MPS devices right now; use TensorFloat-32 is faster, but results in slightly less accurate computations, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ")
+        in_variant = gr.Radio(label="Variant:", value=config.value["variant"], choices=["fp16", None], info="Use half-precision weights will save GPU memory, not all models support that, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ")
         
     gr.Markdown("### Model specific settings")
     with gr.Row():
-        models = list(config.model_configs.keys())
-        in_models = gr.Dropdown(choices=models, label="Model")
+        in_models = gr.Dropdown(choices=list(models.keys()), label="Model")
+        out_model_description = gr.Textbox(value="", label="Description")
     with gr.Row():
         with gr.Column(scale=1):
             in_use_safetensors = gr.Radio(label="Use safe tensors:", choices=["True", "False"], interactive=False)
         with gr.Column(scale=1):
-            in_safety_checker = gr.Radio(label="Enable safety checker:", value=config.current["safety_checker"], choices=[True, False])
-            in_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=config.current["requires_safety_checker"], choices=[True, False])
+            in_safety_checker = gr.Radio(label="Enable safety checker:", value=config.value["safety_checker"], choices=["True", "False"])
+            in_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=config.value["requires_safety_checker"], choices=["True", "False"])
 
     gr.Markdown("### Scheduler")
     with gr.Row():
-        schedulers = list(config.scheduler_configs.keys())
-        in_schedulers = gr.Dropdown(choices=schedulers, label="Scheduler", info="see https://huggingface.co/docs/diffusers/using-diffusers/loading#schedulers" )
+        in_schedulers = gr.Dropdown(choices=list(schedulers.keys()), label="Scheduler", info="see https://huggingface.co/docs/diffusers/using-diffusers/loading#schedulers" )
         out_scheduler_description = gr.Textbox(value="", label="Description")
     
     gr.Markdown("### Adapters")
@@ -232,12 +216,12 @@ with gr.Blocks() as demo:
         
     gr.Markdown("### Inference settings")
     with gr.Row():
-        in_prompt = gr.TextArea(label="Prompt", value=config.current["prompt"])
-        in_negative_prompt = gr.TextArea(label="Negative prompt", value=config.current["negative_prompt"])
+        in_prompt = gr.TextArea(label="Prompt", value=config.value["prompt"])
+        in_negative_prompt = gr.TextArea(label="Negative prompt", value=config.value["negative_prompt"])
     with gr.Row():
-        in_inference_steps = gr.Number(label="Inference steps", value=config.current["inference_steps"])
-        in_manual_seed = gr.Number(label="Manual seed", value=config.current["manual_seed"], info="Set this to -1 or leave it empty to randomly generate an image. A fixed value will result in a similar image for every run")
-        in_guidance_scale = gr.Slider(minimum=0, maximum=1, step=0.01, label="Guidance Scale", value=config.current["guidance_scale"], info="A low guidance scale leads to a faster inference time, with the drawback that negative prompts don’t have any effect on the denoising process.")
+        in_inference_steps = gr.Number(label="Inference steps", value=config.value["inference_steps"])
+        in_manual_seed = gr.Number(label="Manual seed", value=config.value["manual_seed"], info="Set this to -1 or leave it empty to randomly generate an image. A fixed value will result in a similar image for every run")
+        in_guidance_scale = gr.Slider(minimum=0, maximum=1, step=0.01, label="Guidance Scale", value=config.value["guidance_scale"], info="A low guidance scale leads to a faster inference time, with the drawback that negative prompts don’t have any effect on the denoising process.")
         
     gr.Markdown("### Output")
     with gr.Row():
@@ -245,30 +229,30 @@ with gr.Blocks() as demo:
     with gr.Row():
         # out_result = gr.Textbox(label="Status", value="")
         out_image = gr.Image()
-        out_code = gr.Code(config.assemble_code(), label="Code")
+        out_code = gr.Code(assemble_code(config.value), label="Code")
     with gr.Row():
-        out_current_config = gr.Code(value=str(config.current), label="Current config")
+        out_config = gr.Code(value=str(config.value), label="Current config")
     with gr.Row():
-        out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history))
+        out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history.value))
     
-    in_devices.change(device_change, inputs=[in_devices], outputs=[out_current_config, out_code])
-    in_data_type.change(data_type_change, inputs=[in_data_type], outputs=[out_current_config, out_code])
-    in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32], outputs=[out_current_config, out_code])
-    in_variant.change(variant_change, inputs=[in_variant], outputs=[out_current_config, out_code])
-    in_models.change(models_change, inputs=[in_models, in_schedulers], outputs=[in_use_safetensors, in_schedulers, out_current_config, out_code])
-    in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker], outputs=[out_current_config, out_code])
-    in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker], outputs=[out_current_config, out_code])
-    in_schedulers.change(schedulers_change, inputs=[in_schedulers], outputs=[out_scheduler_description, out_current_config, out_code])
-    in_inference_steps.change(inference_steps_change, inputs=[in_inference_steps], outputs=[out_current_config, out_code])
-    in_manual_seed.change(manual_seed_change, inputs=[in_manual_seed], outputs=[out_current_config, out_code])
-    in_guidance_scale.change(guidance_scale_change, inputs=[in_guidance_scale], outputs=[out_current_config, out_code])
-    in_prompt.change(prompt_change, inputs=[in_prompt], outputs=[out_current_config, out_code])
-    in_negative_prompt.change(negative_prompt_change, inputs=[in_negative_prompt], outputs=[out_current_config, out_code])
-    btn_start_pipeline.click(run_inference, inputs=[], outputs=[out_image, out_config_history])
+    in_devices.change(device_change, inputs=[in_devices, config], outputs=[config, out_config, out_code])
+    in_data_type.change(data_type_change, inputs=[in_data_type, config], outputs=[config, out_config, out_code])
+    in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32, config], outputs=[config, out_config, out_code])
+    in_variant.change(variant_change, inputs=[in_variant, config], outputs=[config, out_config, out_code])
+    in_models.change(models_change, inputs=[in_models, in_schedulers, config], outputs=[out_model_description, in_use_safetensors, in_schedulers, config, out_config, out_code])
+    in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker, config], outputs=[config, out_config, out_code])
+    in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker, config], outputs=[config, out_config, out_code])
+    in_schedulers.change(schedulers_change, inputs=[in_schedulers, config], outputs=[out_scheduler_description, config, out_config, out_code])
+    in_inference_steps.change(inference_steps_change, inputs=[in_inference_steps, config], outputs=[config, out_config, out_code])
+    in_manual_seed.change(manual_seed_change, inputs=[in_manual_seed, config], outputs=[config, out_config, out_code])
+    in_guidance_scale.change(guidance_scale_change, inputs=[in_guidance_scale, config], outputs=[config, out_config, out_code])
+    in_prompt.change(prompt_change, inputs=[in_prompt, config], outputs=[config, out_config, out_code])
+    in_negative_prompt.change(negative_prompt_change, inputs=[in_negative_prompt, config], outputs=[config, out_config, out_code])
+    btn_start_pipeline.click(run_inference, inputs=[config, config_history], outputs=[out_image, out_config_history, config_history])
 
     # send current respect initial config to init_config to populate parameters to all relevant input fields
     # if GET parameter is set, it will overwrite initial config parameters
-    demo.load(fn=init_config, inputs=out_current_config, 
+    demo.load(fn=get_config_from_url, inputs=config, 
         outputs=[
             in_models,
             in_devices,

appConfig.json

@@ -3,10 +3,12 @@
         
         "sd-dreambooth-library/solo-levelling-art-style": {
             "use_safetensors": false,
+            "description": "A wonderful model",
             "scheduler": "DDPMScheduler"
         },
         "CompVis/stable-diffusion-v1-4": {
             "use_safetensors": true,
+            "description": "Another wonderful model",
             "scheduler": "DDPMScheduler"
         }
 

config.py

@@ -3,7 +3,41 @@ import base64
 import json
 import torch
 
-def init_config(request: gr.Request, inital_config):
+def get_initial_config():
+    
+    device = None
+    data_type = 'float16'
+    allow_tensorfloat32 = "False"
+    if torch.cuda.is_available():
+        device = "cuda" 
+        data_type = 'bfloat16'
+        allow_tensorfloat32 = "True"
+    elif torch.backends.mps.is_available():
+        device = "mps" 
+    else:
+        device = "cpu"
+
+    config = {
+        "device": device,
+        "model": None,
+        "scheduler": None,
+        "variant": None,
+        "allow_tensorfloat32": allow_tensorfloat32,
+        "use_safetensors": "False",
+        "data_type": data_type,
+        "safety_checker": "False",
+        "requires_safety_checker": "False",
+        "manual_seed": 42,
+        "inference_steps": 10,
+        "guidance_scale": 0.5,
+        "prompt": 'A white rabbit',
+        "negative_prompt": 'lowres, cropped, worst quality, low quality, chat bubble, chat bubbles, ugly',
+    }
+    
+
+    return config
+
+def get_config_from_url(request: gr.Request, initial_config):
     
     encoded_params = request.request.query_params.get('config')
     return_config = {}
@@ -12,7 +46,7 @@ def init_config(request: gr.Request, inital_config):
     if encoded_params is not None:
         decoded_params = base64.b64decode(encoded_params)
         decoded_params = decoded_params.decode('utf-8')
-        decoded_params = decoded_params.replace("'", '"').replace('None', 'null').replace('False', 'false')
+        decoded_params = decoded_params.replace("'", '"').replace('None', 'null').replace('False', 'False')
         dict_params = json.loads(decoded_params)
         
         return_config = dict_params
@@ -20,10 +54,9 @@ def init_config(request: gr.Request, inital_config):
     # otherwise use default initial config
     else:
         
-        inital_config = inital_config.replace("'", '"').replace('None', 'null').replace('False', 'false')
-        dict_inital_config = json.loads(inital_config)
-        
-        return_config = dict_inital_config
+        # initial_config = initial_config.replace("'", '"').replace('None', 'null').replace('False', 'False')
+        # return_config = json.loads(initial_config)
+        return_config = initial_config
 
     return [return_config['model'],
             return_config['device'],
@@ -40,126 +73,82 @@ def init_config(request: gr.Request, inital_config):
             return_config['guidance_scale']
             ]
         
-
-class Config:
-    
-    def __init__(self):
-    
-        self.code = {}
-        self.history = []
-        self.devices = []
-
-        appConfig = self.load_app_config()
-
-        self.model_configs = appConfig.get("models", {})
-        self.scheduler_configs = appConfig.get("schedulers", {})
+def load_app_config():
+    try:
+        with open('appConfig.json', 'r') as f:
+            appConfig = json.load(f)
+    except FileNotFoundError:
+        print("App config file not found.")
+    except json.JSONDecodeError:
+        print("Error decoding JSON in app config file.")
+    except Exception as e:
+        print("An error occurred while loading app config:", str(e))
         
-        # default device
-        self.devices =  appConfig.get("devices", [])
-        device = None
-        data_type = 'float16'
-        allow_tensorfloat32 = False
-        if torch.cuda.is_available():
-            device = "cuda" 
-            data_type = 'bfloat16'
-            allow_tensorfloat32 = True
-        elif torch.backends.mps.is_available():
-            device = "mps" 
-        else:
-            device = "cpu"
-
-        self.current = {
-            "device": device,
-            "model": None,
-            "scheduler": None,
-            "variant": None,
-            "allow_tensorfloat32": allow_tensorfloat32,
-            "use_safetensors": False,
-            "data_type": data_type,
-            "safety_checker": False,
-            "requires_safety_checker": False,
-            "manual_seed": 42,
-            "inference_steps": 10,
-            "guidance_scale": 0.5,
-            "prompt": 'A white rabbit',
-            "negative_prompt": 'lowres, cropped, worst quality, low quality, chat bubble, chat bubbles, ugly',
-        }
-
-        self.assemble_code()
+    return appConfig
 
-    def load_app_config(self):
-        try:
-            with open('appConfig.json', 'r') as f:
-                appConfig = json.load(f)
-        except FileNotFoundError:
-            print("App config file not found.")
-        except json.JSONDecodeError:
-            print("Error decoding JSON in app config file.")
-        except Exception as e:
-            print("An error occurred while loading app config:", str(e))
-            
-        return appConfig
-
-    def set_config(self, key, value):
-        
-        self.current[key] = value
+def set_config(config, key, value):
     
-        return str(self.current)
+    # str_config = str_config.replace("'", '"').replace('None', 'null').replace('False', 'false')
+    # config = json.loads(str_config)
+    config[key] = value
 
-    def get_scheduler_description(self, scheduler):
-        
-        if type(scheduler) != list and scheduler is not None:
-            
-            return self.scheduler_configs[scheduler]
+    return config
 
-        else:
-            
-            return ''
+def assemble_code(str_config):
 
-    def assemble_code(self):
+    # str_config = str_config.replace("'", '"').replace('None', 'null').replace('False', 'false')
+    # config = json.loads(str_config)
+    config = str_config
+    
+    code = {}
+    
+    code['001_code'] = f'''device = "{config['device']}"'''
+    if config['data_type'] == "bfloat16":
+        code['002_data_type'] = 'data_type = torch.bfloat16'
+    else:
+        code['002_data_type'] = 'data_type = torch.float16'
+    code['003_tf32'] = f'torch.backends.cuda.matmul.allow_tf32 = {config["allow_tensorfloat32"]}'
+    
+    if str(config["variant"]) == 'None':
+        code['004_variant'] = f'variant = {config["variant"]}'
+    else:
+        code['004_variant'] = f'variant = "{config["variant"]}"'
+    
         
-        self.code['001_code'] = f'''device = "{self.current['device']}"'''
-        if self.current['data_type'] == "bfloat16":
-            self.code['002_data_type'] = 'data_type = torch.bfloat16'
-        else:
-            self.code['002_data_type'] = 'data_type = torch.float16'
-        self.code['003_tf32'] = f'torch.backends.cuda.matmul.allow_tf32 = {self.current["allow_tensorfloat32"]}'
-        if str(self.current["variant"]) == 'None':
-            self.code['004_variant'] = f'variant = {self.current["variant"]}'
-        else:
-            self.code['004_variant'] = f'variant = "{self.current["variant"]}"'
-        self.code['050_init_pipe'] = f'''pipeline = DiffusionPipeline.from_pretrained(
-                "{self.current['model']}", 
-                use_safetensors=use_safetensors, 
-                torch_dtype=data_type, 
-                variant=variant).to(device)'''
+    code['005_use_safetensors'] = f'''use_safetensors = {config["use_safetensors"]}'''
         
-        self.code['054_requires_safety_checker'] = f'pipeline.requires_safety_checker = {self.current["requires_safety_checker"]}'
+    code['050_init_pipe'] = f'''pipeline = DiffusionPipeline.from_pretrained(
+            "{config['model']}", 
+            use_safetensors=use_safetensors, 
+            torch_dtype=data_type, 
+            variant=variant).to(device)'''
+    
+    code['054_requires_safety_checker'] = f'pipeline.requires_safety_checker = {config["requires_safety_checker"]}'
 
-        if not self.current["safety_checker"] or str(self.current["safety_checker"]).lower == 'false':
-            self.code['055_safety_checker'] = f'pipeline.safety_checker = None'
-        else:
-            self.code['055_safety_checker'] = ''
-        
-        self.code['060_scheduler'] = f'pipeline.scheduler = {self.current["scheduler"]}.from_config(pipeline.scheduler.config)'
-        
-        if self.current['manual_seed'] < 0 or self.current['manual_seed'] is None or self.current['manual_seed'] == '':
-            self.code['091_manual_seed'] = f'# manual_seed = {self.current["manual_seed"]}'
-            self.code['092_generator'] = f'generator = torch.Generator("{self.current["device"]}")'
-        else:
-            self.code['091_manual_seed'] = f'manual_seed = {self.current["manual_seed"]}'
-            self.code['092_generator'] = f'generator = torch.manual_seed(manual_seed)'
+    if str(config["safety_checker"]).lower() == 'false':
+        code['055_safety_checker'] = f'pipeline.safety_checker = None'
+    else:
+        code['055_safety_checker'] = ''
+    
+    code['060_scheduler'] = f'pipeline.scheduler = {config["scheduler"]}.from_config(pipeline.scheduler.config)'
+    
+    if config['manual_seed'] < 0 or config['manual_seed'] is None or config['manual_seed'] == '':
+        code['091_manual_seed'] = f'# manual_seed = {config["manual_seed"]}'
+        code['092_generator'] = f'generator = torch.Generator("{config["device"]}")'
+    else:
+        code['091_manual_seed'] = f'manual_seed = {config["manual_seed"]}'
+        code['092_generator'] = f'generator = torch.manual_seed(manual_seed)'
 
-        self.code["080_prompt"] = f'prompt = "{self.current["prompt"]}"'
-        self.code["085_negative_prompt"] = f'negative_prompt = "{self.current["negative_prompt"]}"'
-        self.code["090_inference_steps"] = f'inference_steps = {self.current["inference_steps"]}'
-        self.code["095_guidance_scale"] = f'guidance_scale = {self.current["guidance_scale"]}'
-        
-        self.code["100_run_inference"] = f'''image = pipeline(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            generator=generator,
-            num_inference_steps=inference_steps, 
-            guidance_scale=guidance_scale).images[0]'''
-                
-        return '\r\n'.join(value[1] for value in sorted(self.code.items()))
+    code["080_prompt"] = f'prompt = "{config["prompt"]}"'
+    code["085_negative_prompt"] = f'negative_prompt = "{config["negative_prompt"]}"'
+    code["090_inference_steps"] = f'inference_steps = {config["inference_steps"]}'
+    code["095_guidance_scale"] = f'guidance_scale = {config["guidance_scale"]}'
+    
+    code["100_run_inference"] = f'''image = pipeline(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        generator=generator,
+        num_inference_steps=inference_steps, 
+        guidance_scale=guidance_scale).images[0]'''
+            
+    return '\r\n'.join(value[1] for value in sorted(code.items()))

helpers.py

@@ -0,0 +1,76 @@
+import torch
+from diffusers import (
+    DDPMScheduler,
+    DDIMScheduler,
+    PNDMScheduler,
+    LMSDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    EulerDiscreteScheduler,
+    DPMSolverMultistepScheduler,
+)
+import base64
+
+def get_variant(str_variant):
+ 
+    if str(str_variant).lower() == 'none':
+        return None
+    else:
+        return str_variant
+
+def get_bool(str_bool):
+    
+    if str(str_bool).lower() == 'false':
+        return False
+    else:
+        return True
+            
+
+def get_data_type(str_data_type):
+    
+    if str_data_type == "bfloat16":
+        return torch.bfloat16 # BFloat16 is not supported on MPS as of 01/2024
+    else:
+        return torch.float16 # Half-precision weights, as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 will save GPU memory
+
+def get_tensorfloat32(allow_tensorfloat32):
+        
+    return True if str(allow_tensorfloat32).lower() == 'true' else False
+
+def get_scheduler(scheduler, pipeline_config):
+    
+    if scheduler == "DDPMScheduler":
+        return DDPMScheduler.from_config(pipeline_config)
+    elif scheduler == "DDIMScheduler":
+        return DDIMScheduler.from_config(pipeline_config)
+    elif scheduler == "PNDMScheduler":
+        return PNDMScheduler.from_config(pipeline_config)
+    elif scheduler == "LMSDiscreteScheduler":
+        return LMSDiscreteScheduler.from_config(pipeline_config)
+    elif scheduler == "EulerAncestralDiscreteScheduler":
+        return EulerAncestralDiscreteScheduler.from_config(pipeline_config)
+    elif scheduler == "EulerDiscreteScheduler":
+        return EulerDiscreteScheduler.from_config(pipeline_config)
+    elif scheduler == "DPMSolverMultistepScheduler":
+        return DPMSolverMultistepScheduler.from_config(pipeline_config)
+    else:
+        return DPMSolverMultistepScheduler.from_config(pipeline_config)
+
+def dict_list_to_markdown_table(config_history):
+
+    if not config_history:
+        return ""
+
+    headers = list(config_history[0].keys())
+    markdown_table = "| share | " + " | ".join(headers) + " |\n"
+    markdown_table += "| ---  | " + " | ".join(["---"] * len(headers)) + " |\n"
+
+    for index, config in enumerate(config_history):
+            
+        encoded_config = base64.b64encode(str(config).encode()).decode()
+        share_link = f'<a target="_blank" href="?config={encoded_config}">📎</a>'
+        markdown_table += f"| {share_link} | " + " | ".join(str(config.get(key, "")) for key in headers) + " |\n"
+
+    markdown_table = '<div style="overflow-x: auto;">\n\n' + markdown_table + '</div>'
+
+    return markdown_table
+