premerge cleanup

requirements_versions.txt

@@ -1,16 +1,30 @@
-accelerate==0.16.0
-diffusers==0.12.1
-einops==0.4.1
-fastapi==0.94.0
+blendmodes==2022
+transformers==4.25.1
+accelerate==0.12.0
+basicsr==1.4.2
 gfpgan==1.3.8
-GitPython==3.1.31
 gradio==3.16.2
-numexpr==2.8.4
-omegaconf==2.3.0
-pandas==1.5.3
+numpy==1.23.3
 Pillow==9.4.0
-protobuf==3.20.3
-pytorch_lightning==1.9.4
 realesrgan==0.3.0
-safetensors==0.3.0
-transformers==4.26.1
+torch
+omegaconf==2.2.3
+pytorch_lightning==1.7.6
+scikit-image==0.19.2
+fonts
+font-roboto
+timm==0.6.7
+piexif==1.1.3
+einops==0.4.1
+jsonmerge==1.8.0
+clean-fid==0.1.29
+resize-right==0.0.2
+torchdiffeq==0.2.3
+kornia==0.6.7
+lark==1.1.2
+inflection==0.5.1
+GitPython==3.1.27
+torchsde==0.2.5
+safetensors==0.2.7
+httpcore<=0.15
+fastapi==0.90.1

test/basic_features/extras_test.py

@@ -0,0 +1,54 @@
+import unittest
+import requests
+from gradio.processing_utils import encode_pil_to_base64
+from PIL import Image
+
+class TestExtrasWorking(unittest.TestCase):
+    def setUp(self):
+        self.url_extras_single = "http://localhost:7860/sdapi/v1/extra-single-image"
+        self.extras_single = {
+            "resize_mode": 0,
+            "show_extras_results": True,
+            "gfpgan_visibility": 0,
+            "codeformer_visibility": 0,
+            "codeformer_weight": 0,
+            "upscaling_resize": 2,
+            "upscaling_resize_w": 128,
+            "upscaling_resize_h": 128,
+            "upscaling_crop": True,
+            "upscaler_1": "None",
+            "upscaler_2": "None",
+            "extras_upscaler_2_visibility": 0,
+            "image": encode_pil_to_base64(Image.open(r"test/test_files/img2img_basic.png"))
+            }
+
+    def test_simple_upscaling_performed(self):
+        self.extras_single["upscaler_1"] = "Lanczos"
+        self.assertEqual(requests.post(self.url_extras_single, json=self.extras_single).status_code, 200)
+
+
+class TestPngInfoWorking(unittest.TestCase):
+    def setUp(self):
+        self.url_png_info = "http://localhost:7860/sdapi/v1/extra-single-image"
+        self.png_info = {
+            "image": encode_pil_to_base64(Image.open(r"test/test_files/img2img_basic.png"))
+        }
+
+    def test_png_info_performed(self):
+        self.assertEqual(requests.post(self.url_png_info, json=self.png_info).status_code, 200)
+
+
+class TestInterrogateWorking(unittest.TestCase):
+    def setUp(self):
+        self.url_interrogate = "http://localhost:7860/sdapi/v1/extra-single-image"
+        self.interrogate = {
+            "image": encode_pil_to_base64(Image.open(r"test/test_files/img2img_basic.png")),
+            "model": "clip"
+        }
+
+    def test_interrogate_performed(self):
+        self.assertEqual(requests.post(self.url_interrogate, json=self.interrogate).status_code, 200)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/basic_features/img2img_test.py

@@ -0,0 +1,66 @@
+import unittest
+import requests
+from gradio.processing_utils import encode_pil_to_base64
+from PIL import Image
+
+
+class TestImg2ImgWorking(unittest.TestCase):
+    def setUp(self):
+        self.url_img2img = "http://localhost:7860/sdapi/v1/img2img"
+        self.simple_img2img = {
+            "init_images": [encode_pil_to_base64(Image.open(r"test/test_files/img2img_basic.png"))],
+            "resize_mode": 0,
+            "denoising_strength": 0.75,
+            "mask": None,
+            "mask_blur": 4,
+            "inpainting_fill": 0,
+            "inpaint_full_res": False,
+            "inpaint_full_res_padding": 0,
+            "inpainting_mask_invert": False,
+            "prompt": "example prompt",
+            "styles": [],
+            "seed": -1,
+            "subseed": -1,
+            "subseed_strength": 0,
+            "seed_resize_from_h": -1,
+            "seed_resize_from_w": -1,
+            "batch_size": 1,
+            "n_iter": 1,
+            "steps": 3,
+            "cfg_scale": 7,
+            "width": 64,
+            "height": 64,
+            "restore_faces": False,
+            "tiling": False,
+            "negative_prompt": "",
+            "eta": 0,
+            "s_churn": 0,
+            "s_tmax": 0,
+            "s_tmin": 0,
+            "s_noise": 1,
+            "override_settings": {},
+            "sampler_index": "Euler a",
+            "include_init_images": False
+            }
+
+    def test_img2img_simple_performed(self):
+        self.assertEqual(requests.post(self.url_img2img, json=self.simple_img2img).status_code, 200)
+
+    def test_inpainting_masked_performed(self):
+        self.simple_img2img["mask"] = encode_pil_to_base64(Image.open(r"test/test_files/mask_basic.png"))
+        self.assertEqual(requests.post(self.url_img2img, json=self.simple_img2img).status_code, 200)
+
+    def test_inpainting_with_inverted_masked_performed(self):
+        self.simple_img2img["mask"] = encode_pil_to_base64(Image.open(r"test/test_files/mask_basic.png"))
+        self.simple_img2img["inpainting_mask_invert"] = True
+        self.assertEqual(requests.post(self.url_img2img, json=self.simple_img2img).status_code, 200)
+
+    def test_img2img_sd_upscale_performed(self):
+        self.simple_img2img["script_name"] = "sd upscale"
+        self.simple_img2img["script_args"] = ["", 8, "Lanczos", 2.0]
+
+        self.assertEqual(requests.post(self.url_img2img, json=self.simple_img2img).status_code, 200)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/basic_features/txt2img_test.py

@@ -0,0 +1,82 @@
+import unittest
+import requests
+
+
+class TestTxt2ImgWorking(unittest.TestCase):
+    def setUp(self):
+        self.url_txt2img = "http://localhost:7860/sdapi/v1/txt2img"
+        self.simple_txt2img = {
+            "enable_hr": False,
+            "denoising_strength": 0,
+            "firstphase_width": 0,
+            "firstphase_height": 0,
+            "prompt": "example prompt",
+            "styles": [],
+            "seed": -1,
+            "subseed": -1,
+            "subseed_strength": 0,
+            "seed_resize_from_h": -1,
+            "seed_resize_from_w": -1,
+            "batch_size": 1,
+            "n_iter": 1,
+            "steps": 3,
+            "cfg_scale": 7,
+            "width": 64,
+            "height": 64,
+            "restore_faces": False,
+            "tiling": False,
+            "negative_prompt": "",
+            "eta": 0,
+            "s_churn": 0,
+            "s_tmax": 0,
+            "s_tmin": 0,
+            "s_noise": 1,
+            "sampler_index": "Euler a"
+        }
+
+    def test_txt2img_simple_performed(self):
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_negative_prompt_performed(self):
+        self.simple_txt2img["negative_prompt"] = "example negative prompt"
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_complex_prompt_performed(self):
+        self.simple_txt2img["prompt"] = "((emphasis)), (emphasis1:1.1), [to:1], [from::2], [from:to:0.3], [alt|alt1]"
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_not_square_image_performed(self):
+        self.simple_txt2img["height"] = 128
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_hrfix_performed(self):
+        self.simple_txt2img["enable_hr"] = True
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_tiling_performed(self):
+        self.simple_txt2img["tiling"] = True
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_restore_faces_performed(self):
+        self.simple_txt2img["restore_faces"] = True
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_with_vanilla_sampler_performed(self):
+        self.simple_txt2img["sampler_index"] = "PLMS"
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+        self.simple_txt2img["sampler_index"] = "DDIM"
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+        self.simple_txt2img["sampler_index"] = "UniPC"
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_multiple_batches_performed(self):
+        self.simple_txt2img["n_iter"] = 2
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+    def test_txt2img_batch_performed(self):
+        self.simple_txt2img["batch_size"] = 2
+        self.assertEqual(requests.post(self.url_txt2img, json=self.simple_txt2img).status_code, 200)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/basic_features/utils_test.py

@@ -0,0 +1,62 @@
+import unittest
+import requests
+
+class UtilsTests(unittest.TestCase):
+  def setUp(self):
+    self.url_options = "http://localhost:7860/sdapi/v1/options"
+    self.url_cmd_flags = "http://localhost:7860/sdapi/v1/cmd-flags"
+    self.url_samplers = "http://localhost:7860/sdapi/v1/samplers"
+    self.url_upscalers = "http://localhost:7860/sdapi/v1/upscalers"
+    self.url_sd_models = "http://localhost:7860/sdapi/v1/sd-models"
+    self.url_hypernetworks = "http://localhost:7860/sdapi/v1/hypernetworks"
+    self.url_face_restorers = "http://localhost:7860/sdapi/v1/face-restorers"
+    self.url_realesrgan_models = "http://localhost:7860/sdapi/v1/realesrgan-models"
+    self.url_prompt_styles = "http://localhost:7860/sdapi/v1/prompt-styles"
+    self.url_embeddings = "http://localhost:7860/sdapi/v1/embeddings"
+
+  def test_options_get(self):
+    self.assertEqual(requests.get(self.url_options).status_code, 200)
+
+  def test_options_write(self):
+    response = requests.get(self.url_options)
+    self.assertEqual(response.status_code, 200)
+
+    pre_value = response.json()["send_seed"]
+
+    self.assertEqual(requests.post(self.url_options, json={"send_seed":not pre_value}).status_code, 200)
+
+    response = requests.get(self.url_options)
+    self.assertEqual(response.status_code, 200)
+    self.assertEqual(response.json()["send_seed"], not pre_value)
+
+    requests.post(self.url_options, json={"send_seed": pre_value})
+
+  def test_cmd_flags(self):
+    self.assertEqual(requests.get(self.url_cmd_flags).status_code, 200)
+
+  def test_samplers(self):
+    self.assertEqual(requests.get(self.url_samplers).status_code, 200)
+
+  def test_upscalers(self):
+    self.assertEqual(requests.get(self.url_upscalers).status_code, 200)
+
+  def test_sd_models(self):
+    self.assertEqual(requests.get(self.url_sd_models).status_code, 200)
+
+  def test_hypernetworks(self):
+    self.assertEqual(requests.get(self.url_hypernetworks).status_code, 200)
+
+  def test_face_restorers(self):
+    self.assertEqual(requests.get(self.url_face_restorers).status_code, 200)
+  
+  def test_realesrgan_models(self):
+    self.assertEqual(requests.get(self.url_realesrgan_models).status_code, 200)
+  
+  def test_prompt_styles(self):
+    self.assertEqual(requests.get(self.url_prompt_styles).status_code, 200)
+
+  def test_embeddings(self):
+    self.assertEqual(requests.get(self.url_embeddings).status_code, 200)
+
+if __name__ == "__main__":
+    unittest.main()

test/server_poll.py

@@ -0,0 +1,24 @@
+import unittest
+import requests
+import time
+
+
+def run_tests(proc, test_dir):
+    timeout_threshold = 240
+    start_time = time.time()
+    while time.time()-start_time < timeout_threshold:
+        try:
+            requests.head("http://localhost:7860/")
+            break
+        except requests.exceptions.ConnectionError:
+            if proc.poll() is not None:
+                break
+    if proc.poll() is None:
+        if test_dir is None:
+            test_dir = "test"
+        suite = unittest.TestLoader().discover(test_dir, pattern="*_test.py", top_level_dir="test")
+        result = unittest.TextTestRunner(verbosity=2).run(suite)
+        return len(result.failures) + len(result.errors)
+    else:
+        print("Launch unsuccessful")
+        return 1

webui.py

@@ -3,7 +3,6 @@ import sys
 import time
 import importlib
 import signal
-import warnings
 import re
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -13,26 +12,12 @@ from packaging import version
 import logging
 logging.getLogger("xformers").addFilter(lambda record: 'A matching Triton is not available' not in record.getMessage())
 
-from modules import paths, timer, import_hook, errors
-
-startup_timer = timer.Timer()
-
-import torch
-import pytorch_lightning # pytorch_lightning should be imported after torch, but it re-enables warnings on import so import once to disable them
-warnings.filterwarnings(action="ignore", category=DeprecationWarning)
-
-startup_timer.record("import torch")
-
-import gradio
-startup_timer.record("import gradio")
-
-import ldm.modules.encoders.modules
-startup_timer.record("import ldm")
-
-from modules import extra_networks, ui_extra_networks_checkpoints
+from modules import import_hook, errors, extra_networks, ui_extra_networks_checkpoints
 from modules import extra_networks_hypernet, ui_extra_networks_hypernets, ui_extra_networks_textual_inversion
 from modules.call_queue import wrap_queued_call, queue_lock, wrap_gradio_gpu_call
 
+import torch
+
 # Truncate version number of nightly/local build of PyTorch to not cause exceptions with CodeFormer or Safetensors
 if ".dev" in torch.__version__ or "+git" in torch.__version__:
     torch.__long_version__ = torch.__version__
@@ -45,6 +30,7 @@ import modules.gfpgan_model as gfpgan
 import modules.img2img
 
 import modules.lowvram
+import modules.paths
 import modules.scripts
 import modules.sd_hijack
 import modules.sd_models
@@ -59,8 +45,6 @@ from modules import modelloader
 from modules.shared import cmd_opts
 import modules.hypernetworks.hypernetwork
 
-startup_timer.record("other imports")
-
 
 if cmd_opts.server_name:
     server_name = cmd_opts.server_name
@@ -103,8 +87,7 @@ def initialize():
     check_versions()
 
     extensions.list_extensions()
-    # localization.list_localizations(cmd_opts.localizations_dir)
-    startup_timer.record("list extensions")
+    localization.list_localizations(cmd_opts.localizations_dir)
 
     if cmd_opts.ui_debug_mode:
         shared.sd_upscalers = upscaler.UpscalerLanczos().scalers
@@ -113,28 +96,16 @@ def initialize():
 
     modelloader.cleanup_models()
     modules.sd_models.setup_model()
-    startup_timer.record("list SD models")
-
     codeformer.setup_model(cmd_opts.codeformer_models_path)
-    startup_timer.record("setup codeformer")
-
     gfpgan.setup_model(cmd_opts.gfpgan_models_path)
-    startup_timer.record("setup gfpgan")
 
     modelloader.list_builtin_upscalers()
-    startup_timer.record("list builtin upscalers")
-
     modules.scripts.load_scripts()
-    startup_timer.record("load scripts")
-
     modelloader.load_upscalers()
-    startup_timer.record("load upscalers")
 
     modules.sd_vae.refresh_vae_list()
-    startup_timer.record("refresh VAE")
 
     modules.textual_inversion.textual_inversion.list_textual_inversion_templates()
-    startup_timer.record("refresh textual inversion templates")
 
     try:
         modules.sd_models.load_model()
@@ -143,7 +114,6 @@ def initialize():
         print("", file=sys.stderr)
         print("Stable diffusion model failed to load, exiting", file=sys.stderr)
         exit(1)
-    startup_timer.record("load SD checkpoint")
 
     shared.opts.data["sd_model_checkpoint"] = shared.sd_model.sd_checkpoint_info.title
 
@@ -151,10 +121,8 @@ def initialize():
     shared.opts.onchange("sd_vae", wrap_queued_call(lambda: modules.sd_vae.reload_vae_weights()), call=False)
     shared.opts.onchange("sd_vae_as_default", wrap_queued_call(lambda: modules.sd_vae.reload_vae_weights()), call=False)
     shared.opts.onchange("temp_dir", ui_tempdir.on_tmpdir_changed)
-    startup_timer.record("opts onchange")
 
     shared.reload_hypernetworks()
-    startup_timer.record("reload hypernets")
 
     ui_extra_networks.intialize()
     ui_extra_networks.register_page(ui_extra_networks_textual_inversion.ExtraNetworksPageTextualInversion())
@@ -163,7 +131,6 @@ def initialize():
 
     extra_networks.initialize()
     extra_networks.register_extra_network(extra_networks_hypernet.ExtraNetworkHypernet())
-    startup_timer.record("extra networks")
 
     if cmd_opts.tls_keyfile is not None and cmd_opts.tls_keyfile is not None:
 
@@ -177,7 +144,6 @@ def initialize():
             print("TLS setup invalid, running webui without TLS")
         else:
             print("Running with TLS")
-        startup_timer.record("TLS")
 
     # make the program just exit at ctrl+c without waiting for anything
     def sigint_handler(sig, frame):
@@ -187,16 +153,13 @@ def initialize():
     signal.signal(signal.SIGINT, sigint_handler)
 
 
-def setup_middleware(app):
-    app.middleware_stack = None
-    app.add_middleware(GZipMiddleware, minimum_size=1000)
+def setup_cors(app):
     if cmd_opts.cors_allow_origins and cmd_opts.cors_allow_origins_regex:
         app.add_middleware(CORSMiddleware, allow_origins=cmd_opts.cors_allow_origins.split(','), allow_origin_regex=cmd_opts.cors_allow_origins_regex, allow_methods=['*'], allow_credentials=True, allow_headers=['*'])
     elif cmd_opts.cors_allow_origins:
         app.add_middleware(CORSMiddleware, allow_origins=cmd_opts.cors_allow_origins.split(','), allow_methods=['*'], allow_credentials=True, allow_headers=['*'])
     elif cmd_opts.cors_allow_origins_regex:
         app.add_middleware(CORSMiddleware, allow_origin_regex=cmd_opts.cors_allow_origins_regex, allow_methods=['*'], allow_credentials=True, allow_headers=['*'])
-    app.build_middleware_stack()
 
 
 def create_api(app):
@@ -220,12 +183,12 @@ def api_only():
     initialize()
 
     app = FastAPI()
-    setup_middleware(app)
+    setup_cors(app)
+    app.add_middleware(GZipMiddleware, minimum_size=1000)
     api = create_api(app)
 
     modules.script_callbacks.app_started_callback(None, app)
 
-    print(f"Startup time: {startup_timer.summary()}.")
     api.launch(server_name="0.0.0.0" if cmd_opts.listen else "127.0.0.1", port=cmd_opts.port if cmd_opts.port else 7861)
 
 
@@ -236,13 +199,10 @@ def webui():
     while 1:
         if shared.opts.clean_temp_dir_at_start:
             ui_tempdir.cleanup_tmpdr()
-            startup_timer.record("cleanup temp dir")
 
         modules.script_callbacks.before_ui_callback()
-        startup_timer.record("scripts before_ui_callback")
 
         shared.demo = modules.ui.create_ui()
-        startup_timer.record("create ui")
 
         if cmd_opts.gradio_queue:
             shared.demo.queue(64)
@@ -269,15 +229,15 @@ def webui():
         # after initial launch, disable --autolaunch for subsequent restarts
         cmd_opts.autolaunch = False
 
-        startup_timer.record("gradio launch")
-
         # gradio uses a very open CORS policy via app.user_middleware, which makes it possible for
         # an attacker to trick the user into opening a malicious HTML page, which makes a request to the
         # running web ui and do whatever the attacker wants, including installing an extension and
         # running its code. We disable this here. Suggested by RyotaK.
         app.user_middleware = [x for x in app.user_middleware if x.cls.__name__ != 'CORSMiddleware']
 
-        setup_middleware(app)
+        setup_cors(app)
+
+        app.add_middleware(GZipMiddleware, minimum_size=1000)
 
         modules.progress.setup_progress_api(app)
 
@@ -287,9 +247,6 @@ def webui():
         ui_extra_networks.add_pages_to_demo(app)
 
         modules.script_callbacks.app_started_callback(shared.demo, app)
-        startup_timer.record("scripts app_started_callback")
-
-        print(f"Startup time: {startup_timer.summary()}.")
 
         wait_on_server(shared.demo)
         print('Restarting UI...')