Update app.py

app.py

@@ -1,3 +1,4 @@
+from frontend.webui.ui import start_webui
 import json
 from argparse import ArgumentParser
 
@@ -261,253 +262,8 @@ if args.noimagesave:
 else:
     app_settings.settings.generated_images.save_image = True
 
-if not args.realtime:
-    # To minimize realtime mode dependencies
-    from backend.upscale.upscaler import upscale_image
-    from frontend.cli_interactive import interactive_mode
 
-if args.gui:
-    from frontend.gui.ui import start_gui
-
-    print("Starting desktop GUI mode(Qt)")
-    start_gui(
-        [],
-        app_settings,
-    )
-elif args.webui:
-    from frontend.webui.ui import start_webui
-
-    print("Starting web UI mode")
-    start_webui(
-        args.share,
-    )
-elif args.realtime:
-    from frontend.webui.realtime_ui import start_realtime_text_to_image
-
-    print("Starting realtime text to image(EXPERIMENTAL)")
-    start_realtime_text_to_image(args.share)
-elif args.api:
-    from backend.api.web import start_web_server
-
-    start_web_server()
-
-else:
-    context = get_context(InterfaceType.CLI)
-    config = app_settings.settings
-
-    if args.use_openvino:
-        config.lcm_diffusion_setting.openvino_lcm_model_id = args.openvino_lcm_model_id
-    else:
-        config.lcm_diffusion_setting.lcm_model_id = args.lcm_model_id
-
-    config.lcm_diffusion_setting.prompt = args.prompt
-    config.lcm_diffusion_setting.negative_prompt = args.negative_prompt
-    config.lcm_diffusion_setting.image_height = args.image_height
-    config.lcm_diffusion_setting.image_width = args.image_width
-    config.lcm_diffusion_setting.guidance_scale = args.guidance_scale
-    config.lcm_diffusion_setting.number_of_images = args.number_of_images
-    config.lcm_diffusion_setting.inference_steps = args.inference_steps
-    config.lcm_diffusion_setting.strength = args.strength
-    config.lcm_diffusion_setting.seed = args.seed
-    config.lcm_diffusion_setting.use_openvino = args.use_openvino
-    config.lcm_diffusion_setting.use_tiny_auto_encoder = args.use_tiny_auto_encoder
-    config.lcm_diffusion_setting.use_lcm_lora = args.use_lcm_lora
-    config.lcm_diffusion_setting.lcm_lora.base_model_id = args.base_model_id
-    config.lcm_diffusion_setting.lcm_lora.lcm_lora_id = args.lcm_lora_id
-    config.lcm_diffusion_setting.diffusion_task = DiffusionTask.text_to_image.value
-    config.lcm_diffusion_setting.lora.enabled = False
-    config.lcm_diffusion_setting.lora.path = args.lora
-    config.lcm_diffusion_setting.lora.weight = args.lora_weight
-    config.lcm_diffusion_setting.lora.fuse = True
-    if config.lcm_diffusion_setting.lora.path:
-        config.lcm_diffusion_setting.lora.enabled = True
-    if args.usejpeg:
-        config.generated_images.format = ImageFormat.JPEG.value.upper()
-    if args.seed > -1:
-        config.lcm_diffusion_setting.use_seed = True
-    else:
-        config.lcm_diffusion_setting.use_seed = False
-    config.lcm_diffusion_setting.use_offline_model = args.use_offline_model
-    config.lcm_diffusion_setting.use_safety_checker = args.use_safety_checker
-
-    # Read custom settings from JSON file
-    custom_settings = {}
-    if args.custom_settings:
-        with open(args.custom_settings) as f:
-            custom_settings = json.load(f)
-
-    # Basic ControlNet settings; if ControlNet is enabled, an image is
-    # required even in txt2img mode
-    config.lcm_diffusion_setting.controlnet = None
-    controlnet_settings_from_dict(
-        config.lcm_diffusion_setting,
-        custom_settings,
-    )
-
-    # Interactive mode
-    if args.interactive:
-        # wrapper(interactive_mode, config, context)
-        config.lcm_diffusion_setting.lora.fuse = False
-        interactive_mode(config, context)
-
-    # Start of non-interactive CLI image generation
-    if args.img2img and args.file != "":
-        config.lcm_diffusion_setting.init_image = Image.open(args.file)
-        config.lcm_diffusion_setting.diffusion_task = DiffusionTask.image_to_image.value
-    elif args.img2img and args.file == "":
-        print("Error : You need to specify a file in img2img mode")
-        exit()
-    elif args.upscale and args.file == "" and args.custom_settings == None:
-        print("Error : You need to specify a file in SD upscale mode")
-        exit()
-    elif (
-        args.prompt == ""
-        and args.file == ""
-        and args.custom_settings == None
-        and not args.benchmark
-    ):
-        print("Error : You need to provide a prompt")
-        exit()
-
-    if args.upscale:
-        # image = Image.open(args.file)
-        output_path = FastStableDiffusionPaths.get_upscale_filepath(
-            args.file,
-            2,
-            config.generated_images.format,
-        )
-        result = upscale_image(
-            context,
-            args.file,
-            output_path,
-            2,
-        )
-    # Perform Tiled SD upscale (EXPERIMENTAL)
-    elif args.sdupscale:
-        if args.use_openvino:
-            config.lcm_diffusion_setting.strength = 0.3
-        upscale_settings = None
-        if custom_settings != {}:
-            upscale_settings = custom_settings
-        filepath = args.file
-        output_format = config.generated_images.format
-        if upscale_settings:
-            filepath = upscale_settings["source_file"]
-            output_format = upscale_settings["output_format"].upper()
-        output_path = FastStableDiffusionPaths.get_upscale_filepath(
-            filepath,
-            2,
-            output_format,
-        )
-
-        generate_upscaled_image(
-            config,
-            filepath,
-            config.lcm_diffusion_setting.strength,
-            upscale_settings=upscale_settings,
-            context=context,
-            tile_overlap=32 if config.lcm_diffusion_setting.use_openvino else 16,
-            output_path=output_path,
-            image_format=output_format,
-        )
-        exit()
-    # If img2img argument is set and prompt is empty, use image variations mode
-    elif args.img2img and args.prompt == "":
-        for i in range(0, args.batch_count):
-            generate_image_variations(
-                config.lcm_diffusion_setting.init_image, args.strength
-            )
-    else:
-
-        if args.benchmark:
-            print("Initializing benchmark...")
-            bench_lcm_setting = config.lcm_diffusion_setting
-            bench_lcm_setting.prompt = "a cat"
-            bench_lcm_setting.use_tiny_auto_encoder = False
-            context.generate_text_to_image(
-                settings=config,
-                device=DEVICE,
-            )
-            latencies = []
-
-            print("Starting benchmark please wait...")
-            for _ in range(3):
-                context.generate_text_to_image(
-                    settings=config,
-                    device=DEVICE,
-                )
-                latencies.append(context.latency)
-
-            avg_latency = sum(latencies) / 3
-
-            bench_lcm_setting.use_tiny_auto_encoder = True
-
-            context.generate_text_to_image(
-                settings=config,
-                device=DEVICE,
-            )
-            latencies = []
-            for _ in range(3):
-                context.generate_text_to_image(
-                    settings=config,
-                    device=DEVICE,
-                )
-                latencies.append(context.latency)
-
-            avg_latency_taesd = sum(latencies) / 3
-
-            benchmark_name = ""
-
-            if config.lcm_diffusion_setting.use_openvino:
-                benchmark_name = "OpenVINO"
-            else:
-                benchmark_name = "PyTorch"
-
-            bench_model_id = ""
-            if bench_lcm_setting.use_openvino:
-                bench_model_id = bench_lcm_setting.openvino_lcm_model_id
-            elif bench_lcm_setting.use_lcm_lora:
-                bench_model_id = bench_lcm_setting.lcm_lora.base_model_id
-            else:
-                bench_model_id = bench_lcm_setting.lcm_model_id
-
-            benchmark_result = [
-                ["Device", f"{DEVICE.upper()},{get_device_name()}"],
-                ["Stable Diffusion Model", bench_model_id],
-                [
-                    "Image Size ",
-                    f"{bench_lcm_setting.image_width}x{bench_lcm_setting.image_height}",
-                ],
-                [
-                    "Inference Steps",
-                    f"{bench_lcm_setting.inference_steps}",
-                ],
-                [
-                    "Benchmark Passes",
-                    3,
-                ],
-                [
-                    "Average Latency",
-                    f"{round(avg_latency,3)} sec",
-                ],
-                [
-                    "Average Latency(TAESD* enabled)",
-                    f"{round(avg_latency_taesd,3)} sec",
-                ],
-            ]
-            print()
-            print(
-                f"                          FastSD Benchmark - {benchmark_name:8}                         "
-            )
-            print(f"-" * 80)
-            for benchmark in benchmark_result:
-                print(f"{benchmark[0]:35} - {benchmark[1]}")
-            print(f"-" * 80)
-            print("*TAESD - Tiny AutoEncoder for Stable Diffusion")
-
-        else:
-            for i in range(0, args.batch_count):
-                context.generate_text_to_image(
-                    settings=config,
-                    device=DEVICE,
-                )
+print("Starting web UI mode")
+start_webui(
+    args.share,
+)