using class as config

app.py

@@ -22,43 +22,13 @@ from gradio import Interface
 from diffusers import AutoencoderKL
 import pandas as pd 
 import base64
-from config import *
-from change_handlers import *
+from config import 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
-config, devices, model_configs, scheduler_configs, code = get_inital_config()
-
-models = list(model_configs.keys())
-schedulers = list(scheduler_configs.keys())
-
-device                  = config["device"]
-model                   = config["model"]
-scheduler               = config["scheduler"]
-variant                 = config["variant"]
-allow_tensorfloat32     = config["allow_tensorfloat32"]
-use_safetensors         = config["use_safetensors"]
-data_type               = config["data_type"]
-safety_checker          = config["safety_checker"]
-requires_safety_checker = config["requires_safety_checker"]
-manual_seed             = config["manual_seed"]
-inference_steps         = config["inference_steps"]
-guidance_scale          = config["guidance_scale"]
-prompt                  = config["prompt"]
-negative_prompt         = config["negative_prompt"]
-
-config_history = []
+config = Config()
 
 def device_change(device):
     
-    code[code_pos_device] = f'''device = "{device}"'''
-    config['device'] = device
-    
-    return get_sorted_code(), str(config)
+    return config.set_config('device', device), config.assemble_code()
 
 def models_change(model, scheduler):
         
@@ -67,148 +37,72 @@ def models_change(model, scheduler):
     # no model selected (because this is UI init run)
     if type(model) != list and model is not None:
         
-        use_safetensors = str(model_configs[model]['use_safetensors'])
+        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 = model_configs[model]['scheduler']
-            
-    code[code_pos_init_pipeline] = f'''pipeline = DiffusionPipeline.from_pretrained(
-            "{model}", 
-            use_safetensors=use_safetensors, 
-            torch_dtype=data_type, 
-            variant=variant).to(device)'''
-    config['model'] = model
+            scheduler = config.model_configs[model]['scheduler']
 
-    safety_checker_change(safety_checker)
-    requires_safety_checker_change(requires_safety_checker)
+    safety_checker_change(config.current["safety_checker"])
+    requires_safety_checker_change(config.current["requires_safety_checker"])
 
-    return get_sorted_code(), use_safetensors, scheduler, str(config)
+    return use_safetensors, scheduler, config.set_config('model', model), config.assemble_code()
 
-def data_type_change(selected_data_type):
+def data_type_change(data_type):
 
-    config['data_type'] = data_type
+    return config.set_config('data_type', data_type), config.assemble_code()
 
-    get_data_type(selected_data_type)
-    return get_sorted_code(), str(config)
-
-def get_data_type(selected_data_type):
+def get_data_type(str_data_type):
     
-    if selected_data_type == "bfloat16":
-        code[code_pos_data_type] = 'data_type = torch.bfloat16'
-        data_type = torch.bfloat16 # BFloat16 is not supported on MPS as of 01/2024
+    if str_data_type == "bfloat16":
+        return torch.bfloat16 # BFloat16 is not supported on MPS as of 01/2024
     else:
-        code[code_pos_data_type] = 'data_type = torch.float16'
-        data_type = torch.float16 # Half-precision weights, as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 will save GPU memory
-
-    return data_type
+        return torch.float16 # Half-precision weights, as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 will save GPU memory
 
 def tensorfloat32_change(allow_tensorfloat32):  
-    
-    config['allow_tensorfloat32'] = allow_tensorfloat32
-
-    get_tensorfloat32(allow_tensorfloat32)
-    
-    return get_sorted_code(), str(config)
-
-def get_tensorfloat32(allow_tensorfloat32):
-    
-    code[code_pos_tf32] = f'torch.backends.cuda.matmul.allow_tf32 = {allow_tensorfloat32}'
-    
-    return True if str(allow_tensorfloat32).lower() == 'true' else False
+        
+    return config.set_config('allow_tensorfloat32', allow_tensorfloat32), config.assemble_code()
 
 def inference_steps_change(inference_steps):
     
-    config['inference_steps'] = inference_steps
-    code[code_pos_inference_steps] = f'inference_steps = {inference_steps}'
-    
-    return get_sorted_code(), str(config)
+    return config.set_config('inference_steps', inference_steps), config.assemble_code()
 
 def manual_seed_change(manual_seed):
-    
-    config['manual_seed'] = manual_seed
-    
-    if manual_seed < 0 or manual_seed is None or manual_seed == '':
-        code[code_pos_manual_seed] = f'# manual_seed = {manual_seed}'
-        generator = f'generator = torch.Generator("{device}")'
-    else:
-        code[code_pos_manual_seed] = f'manual_seed = {manual_seed}'
-        generator = f'generator = torch.manual_seed(manual_seed)'
-        
-    code[code_pos_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 get_sorted_code(), str(config)
+            
+    return config.set_config('manual_seed', manual_seed), config.assemble_code()
 
 def guidance_scale_change(guidance_scale):
     
-    config['guidance_scale'] = guidance_scale
-    code[code_pos_guidance_scale] = f'guidance_scale = {guidance_scale}'
-    
-    return get_sorted_code(), str(config)
+    return config.set_config('guidance_scale', guidance_scale), config.assemble_code()
 
 def prompt_change(prompt):
     
-    config['prompt'] = prompt
-    code[code_pos_prompt] = f'prompt = {prompt}'
-
-    return get_sorted_code(), str(config)
+    return config.set_config('prompt', prompt), config.assemble_code()
 
 def negative_prompt_change(negative_prompt):
     
-    config['negative_prompt'] = negative_prompt
-    code[code_pos_negative_prompt] = f'negative_prompt = {negative_prompt}'
-
-    return get_sorted_code(), str(config)
+    return config.set_config('negative_prompt', negative_prompt), config.assemble_code()
 
 def variant_change(variant):
     
-    config['variant'] = variant
-    
-    if str(variant) == 'None':
-        code[code_pos_variant] = f'variant = {variant}'
-    else:
-        code[code_pos_variant] = f'variant = "{variant}"'
-
-    return get_sorted_code(), str(config)
+    return config.set_config('variant', variant), config.assemble_code()
     
 def safety_checker_change(safety_checker):
-    
-    config['safety_checker'] = safety_checker
-    
-    if not safety_checker or str(safety_checker).lower == 'false':
-        code[code_pos_safety_checker] = f'pipeline.safety_checker = None'
-    else:
-        code[code_pos_safety_checker] = ''
-    
-    return get_sorted_code(), str(config)
+        
+    return config.set_config('safety_checker', safety_checker), config.assemble_code()
 
 def requires_safety_checker_change(requires_safety_checker):
     
-    code[code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {requires_safety_checker}'
-    
-    config['requires_safety_checker'] = requires_safety_checker
-    
-    return get_sorted_code(), str(config)
+    return config.set_config('requires_safety_checker', requires_safety_checker), config.assemble_code()
 
 def schedulers_change(scheduler):
     
-    if type(scheduler) != list and scheduler is not None:
+    return config.get_scheduler_description(scheduler), config.set_config('scheduler', scheduler), config.assemble_code()
 
-        code[code_pos_scheduler] = f'pipeline.scheduler = {scheduler}.from_config(pipeline.scheduler.config)'
-    
-        config['scheduler'] = scheduler
-        
-        return get_sorted_code(), scheduler_configs[scheduler], str(config)
-
-    else:
+def get_tensorfloat32(allow_tensorfloat32):
         
-        return get_sorted_code(), '', str(config)
+    return True if str(allow_tensorfloat32).lower() == 'true' else False
 
 def get_scheduler(scheduler, config):
     
@@ -228,7 +122,33 @@ def get_scheduler(scheduler, config):
         return DPMSolverMultistepScheduler.from_config(config)
     else:
         return DPMSolverMultistepScheduler.from_config(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
+config.set_inital_config()
+# config.current, devices, model_configs, scheduler_configs, code = config.get_inital_config()
+
+# device                  = config.current["device"]
+# model                   = config.current["model"]
+# scheduler               = config.current["scheduler"]
+# variant                 = config.current["variant"]
+# allow_tensorfloat32     = config.current["allow_tensorfloat32"]
+# use_safetensors         = config.current["use_safetensors"]
+# data_type               = config.current["data_type"]
+# safety_checker          = config.current["safety_checker"]
+# requires_safety_checker = config.current["requires_safety_checker"]
+# manual_seed             = config.current["manual_seed"]
+# inference_steps         = config.current["inference_steps"]
+# guidance_scale          = config.current["guidance_scale"]
+# prompt                  = config.current["prompt"]
+# negative_prompt         = config.current["negative_prompt"]
+
+config_history = []
+
 # pipeline
 def run_inference(model,
                     device, 
@@ -245,26 +165,24 @@ def run_inference(model,
                     guidance_scale,
                     progress=gr.Progress(track_tqdm=True)):
     
-    if model != None and scheduler != None:
+    if config.current["model"] != None and config.current["scheduler"] != None:
         
         progress((1,3), desc="Preparing pipeline initialization...")
         
-        torch.backends.cuda.matmul.allow_tf32 = get_tensorfloat32(allow_tensorfloat32) # Use TensorFloat-32 as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 faster, but slightly less accurate computations
-
-        bool_use_safetensors = True if use_safetensors.lower() == 'true' else False
+        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
         
         progress((2,3), desc="Initializing pipeline...")
         
         pipeline = DiffusionPipeline.from_pretrained(
-            model, 
-            use_safetensors=bool_use_safetensors, 
-            torch_dtype=get_data_type(data_type), 
-            variant=variant).to(device)
+            config.current["model"], 
+            use_safetensors=config.current["use_safetensors"], 
+            torch_dtype=get_data_type(config.current["data_type"]), 
+            variant=variant).to(config.current["device"])
         
-        if safety_checker is None or str(safety_checker).lower == 'false':
+        if config.current["safety_checker"] is None or str(config.current["safety_checker"]).lower == 'false':
             pipeline.safety_checker = None 
 
-        pipeline.requires_safety_checker = bool(requires_safety_checker)
+        pipeline.requires_safety_checker = config.current["requires_safety_checker"]
                 
         pipeline.scheduler = get_scheduler(scheduler, pipeline.scheduler.config)
         
@@ -283,7 +201,7 @@ def run_inference(model,
             num_inference_steps=int(inference_steps), 
             guidance_scale=float(guidance_scale)).images[0]
         
-        config_history.append(config.copy())
+        config_history.append(config.current.copy())
 
         return image, dict_list_to_markdown_table(config_history)
     
@@ -300,8 +218,6 @@ def dict_list_to_markdown_table(config_history):
     markdown_table = "| share | " + " | ".join(headers) + " |\n"
     markdown_table += "| ---  | " + " | ".join(["---"] * len(headers)) + " |\n"
 
-    print('#######################')
-
     for index, config in enumerate(config_history):
             
         encoded_config = base64.b64encode(str(config).encode()).decode()
@@ -321,23 +237,25 @@ with gr.Blocks() as demo:
                 </small>''')
     gr.Markdown("### Device specific settings")
     with gr.Row():
-        in_devices = gr.Dropdown(label="Device:", value=device, choices=devices, filterable=True, multiselect=False, allow_custom_value=True)
-        in_data_type = gr.Radio(label="Data Type:", 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=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=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.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 ")
         
     gr.Markdown("### Model specific settings")
     with gr.Row():
+        models = list(config.model_configs.keys())
         in_models = gr.Dropdown(choices=models, label="Model")
     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=safety_checker, choices=[True, False])
-            in_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=requires_safety_checker, choices=[True, False])
+            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])
 
     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" )
         out_scheduler_description = gr.Textbox(value="", label="Description")
     
@@ -347,12 +265,12 @@ with gr.Blocks() as demo:
         
     gr.Markdown("### Inference settings")
     with gr.Row():
-        in_prompt = gr.TextArea(label="Prompt", value=prompt)
-        in_negative_prompt = gr.TextArea(label="Negative prompt", value=negative_prompt)
+        in_prompt = gr.TextArea(label="Prompt", value=config.current["prompt"])
+        in_negative_prompt = gr.TextArea(label="Negative prompt", value=config.current["negative_prompt"])
     with gr.Row():
-        in_inference_steps = gr.Number(label="Inference steps", value=inference_steps)
-        in_manual_seed = gr.Number(label="Manual seed", 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=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.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.")
         
     gr.Markdown("### Output")
     with gr.Row():
@@ -360,25 +278,25 @@ with gr.Blocks() as demo:
     with gr.Row():
         # out_result = gr.Textbox(label="Status", value="")
         out_image = gr.Image()
-        out_code = gr.Code(get_sorted_code(), label="Code")
+        out_code = gr.Code(config.assemble_code(), label="Code")
     with gr.Row():
-        out_current_config = gr.Code(value=str(config), label="Current config")
+        out_current_config = gr.Code(value=str(config.current), label="Current config")
     with gr.Row():
         out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history))
     
-    in_devices.change(device_change, inputs=[in_devices], outputs=[out_code, out_current_config])
-    in_data_type.change(data_type_change, inputs=[in_data_type], outputs=[out_code, out_current_config])
-    in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32], outputs=[out_code, out_current_config])
-    in_variant.change(variant_change, inputs=[in_variant], outputs=[out_code, out_current_config])
-    in_models.change(models_change, inputs=[in_models, in_schedulers], outputs=[out_code, in_use_safetensors, in_schedulers, out_current_config])
-    in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker], outputs=[out_code, out_current_config])
-    in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker], outputs=[out_code, out_current_config])
-    in_schedulers.change(schedulers_change, inputs=[in_schedulers], outputs=[out_code, out_scheduler_description, out_current_config])
-    in_inference_steps.change(inference_steps_change, inputs=[in_inference_steps], outputs=[out_code, out_current_config])
-    in_manual_seed.change(manual_seed_change, inputs=[in_manual_seed], outputs=[out_code, out_current_config])
-    in_guidance_scale.change(guidance_scale_change, inputs=[in_guidance_scale], outputs=[out_code, out_current_config])
-    in_prompt.change(prompt_change, inputs=[in_prompt], outputs=[out_code, out_current_config])
-    in_negative_prompt.change(negative_prompt_change, inputs=[in_negative_prompt], outputs=[out_code, out_current_config])
+    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=[
         in_models, 
         in_devices,
@@ -397,7 +315,7 @@ with gr.Blocks() as demo:
             out_image,
             out_config_history])
 
-    demo.load(fn=init_config, inputs=out_current_config, 
+    demo.load(fn=config.init_config, inputs=out_current_config, 
         outputs=[
             in_models,
             in_devices,

config.py

@@ -3,135 +3,187 @@ import base64
 import json
 import torch
 
-code = {}
-code_pos_device = '001_code'
-code_pos_data_type = '002_data_type'
-code_pos_tf32 = '003_tf32'
-code_pos_variant = '004_variant'
-code_pos_init_pipeline = '050_init_pipe'
-code_pos_requires_safety_checker = '054_requires_safety_checker'
-code_pos_safety_checker = '055_safety_checker'
-code_pos_scheduler = '060_scheduler'
-code_pos_generator = '070_generator'
-code_pos_prompt = '080_prompt'
-code_pos_negative_prompt = '085_negative_prompt'
-code_pos_inference_steps = '090_inference_steps'
-code_pos_manual_seed = '091_manual_seed'
-code_pos_guidance_scale = '095_guidance_scale'
-code_pos_run_inference = '100_run_inference'
-
-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))
+class Config:
+    
+    def __init__(self):
+    
+        self.code = {}
+        self.history = []
+        self.devices = []
+
+    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_inital_config(self):
+
+        appConfig = self.load_app_config()
+
+        self.model_configs = appConfig.get("models", {})
+        self.scheduler_configs = appConfig.get("schedulers", {})
         
-    return appConfig
+        # 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"
 
-def get_inital_config():
+        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',
+        }
 
-    appConfig = load_app_config()
+        self.assemble_code()
+        # code output order
+        # self.code[self.code_pos_device] = f'device = "{device}"'
+        # self.code[self.code_pos_variant] = f'variant = {initial_config["variant"]}'
+        # self.code[self.code_pos_tf32] = f'torch.backends.cuda.matmul.allow_tf32 = {initial_config["allow_tensorfloat32"]}'
+        # self.code[self.code_pos_data_type] = 'data_type = torch.bfloat16'
+        # self.code[self.code_pos_init_pipeline] = 'sys.exit("No model selected!")'
+        # self.code[self.code_pos_safety_checker] = 'pipeline.safety_checker = None'
+        # self.code[self.code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {initial_config["requires_safety_checker"]}'
+        # self.code[self.code_pos_scheduler] = 'sys.exit("No scheduler selected!")'
+        # self.code[self.code_pos_generator] = f'generator = torch.Generator("{device}")'
+        # self.code[self.code_pos_prompt] = f'prompt = "{initial_config["prompt"]}"'
+        # self.code[self.code_pos_negative_prompt] = f'negative_prompt = "{initial_config["negative_prompt"]}"'
+        # self.code[self.code_pos_inference_steps] = f'inference_steps = {initial_config["inference_steps"]}'
+        # self.code[self.code_pos_manual_seed] = f'manual_seed = {initial_config["inference_steps"]}'
+        # self.code[self.code_pos_guidance_scale] = f'guidance_scale = {initial_config["guidance_scale"]}'
+        # self.code[self.code_pos_run_inference] = f'''image = pipeline(
+        #     prompt=prompt,
+        #     negative_prompt=negative_prompt,
+        #     generator=generator.manual_seed(manual_seed),
+        #     num_inference_steps=inference_steps, 
+        #     guidance_scale=guidance_scale).images[0]'''
 
-    model_configs = appConfig.get("models", {})
-    scheduler_configs = appConfig.get("schedulers", {})
-    
-    # default device
-    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"
-
-    initial_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',
-    }
-
-    # code output order
-    code[code_pos_device] = f'device = "{device}"'
-    code[code_pos_variant] = f'variant = {initial_config["variant"]}'
-    code[code_pos_tf32] = f'torch.backends.cuda.matmul.allow_tf32 = {initial_config["allow_tensorfloat32"]}'
-    code[code_pos_data_type] = 'data_type = torch.bfloat16'
-    code[code_pos_init_pipeline] = 'sys.exit("No model selected!")'
-    code[code_pos_safety_checker] = 'pipeline.safety_checker = None'
-    code[code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {initial_config["requires_safety_checker"]}'
-    code[code_pos_scheduler] = 'sys.exit("No scheduler selected!")'
-    code[code_pos_generator] = f'generator = torch.Generator("{device}")'
-    code[code_pos_prompt] = f'prompt = "{initial_config["prompt"]}"'
-    code[code_pos_negative_prompt] = f'negative_prompt = "{initial_config["negative_prompt"]}"'
-    code[code_pos_inference_steps] = f'inference_steps = {initial_config["inference_steps"]}'
-    code[code_pos_manual_seed] = f'manual_seed = {initial_config["manual_seed"]}'
-    code[code_pos_guidance_scale] = f'guidance_scale = {initial_config["guidance_scale"]}'
-    code[code_pos_run_inference] = f'''image = pipeline(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        generator=generator.manual_seed(manual_seed),
-        num_inference_steps=inference_steps, 
-        guidance_scale=guidance_scale).images[0]'''
-
-    return initial_config, devices, model_configs, scheduler_configs, code
-
-def init_config(request: gr.Request, inital_config):
-    
-    encoded_params = request.request.query_params.get('config')
-    return_config = {}
-
-    # get configuration from URL if GET parameter `share` is set
-    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')
-        dict_params = json.loads(decoded_params)
+        # return initial_config, devices, model_configs, scheduler_configs, self.code
+
+    def init_config(self, request: gr.Request, inital_config):
         
-        return_config = dict_params
+        encoded_params = request.request.query_params.get('config')
+        return_config = {}
+
+        # get configuration from URL if GET parameter `share` is set
+        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')
+            dict_params = json.loads(decoded_params)
             
-    # otherwise use default initial config
-    else:
+            return_config = dict_params
+                
+        # 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
+
+        return [return_config['model'],
+                return_config['device'],
+                return_config['use_safetensors'],
+                return_config['data_type'],
+                return_config['variant'],
+                return_config['safety_checker'],
+                return_config['requires_safety_checker'],
+                return_config['scheduler'],
+                return_config['prompt'],
+                return_config['negative_prompt'],
+                return_config['inference_steps'],
+                return_config['manual_seed'],
+                return_config['guidance_scale']
+                ]
         
-        inital_config = inital_config.replace("'", '"').replace('None', 'null').replace('False', 'false')
-        dict_inital_config = json.loads(inital_config)
+    def set_config(self, key, value):
         
-        return_config = dict_inital_config
-
-    return [return_config['model'],
-            return_config['device'],
-            return_config['use_safetensors'],
-            return_config['data_type'],
-            return_config['variant'],
-            return_config['safety_checker'],
-            return_config['requires_safety_checker'],
-            return_config['scheduler'],
-            return_config['prompt'],
-            return_config['negative_prompt'],
-            return_config['inference_steps'],
-            return_config['manual_seed'],
-            return_config['guidance_scale']
-            ]
+        self.current[key] = value
     
-def get_sorted_code():
-    
-    return '\r\n'.join(value[1] for value in sorted(code.items()))
+        return str(self.current)
+
+    def get_scheduler_description(self, scheduler):
+        
+        if type(scheduler) != list and scheduler is not None:
+            
+            return self.scheduler_configs[scheduler]
+
+        else:
+            
+            return ''
+
+    def assemble_code(self):
+        
+        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)'''
+        
+        self.code['054_requires_safety_checker'] = f'pipeline.requires_safety_checker = {self.current["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['070_generator'] = f'generator = torch.Generator("{self.current["device"]}")'
+            self.code['091_manual_seed'] = f'# manual_seed = {self.current["manual_seed"]}'
+        else:
+            self.code['070_generator'] = f'generator = torch.manual_seed(manual_seed)'
+            self.code['091_manual_seed'] = f'manual_seed = {self.current["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={self.code["070_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()))