From 259768f27fc4da61000610bc81a16f0152b36550 Mon Sep 17 00:00:00 2001
From: AUTOMATIC1111 <16777216c@gmail.com>
Date: Sat, 9 Sep 2023 08:38:42 +0300
Subject: fix the bug in script-info API

---
 modules/scripts.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index e8518ad0..f1f17a5f 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -491,11 +491,15 @@ class ScriptRunner:
 
             arg_info = api_models.ScriptArg(label=control.label or "")
 
-            for field in ("value", "minimum", "maximum", "step", "choices"):
+            for field in ("value", "minimum", "maximum", "step"):
                 v = getattr(control, field, None)
                 if v is not None:
                     setattr(arg_info, field, v)
 
+            choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
+            if choices is not None:
+                setattr(arg_info, 'choices', [x[0] if isinstance(x, tuple) else x for x in choices])
+
             api_args.append(arg_info)
 
         script.api_info = api_models.ScriptInfo(
-- 
cgit v1.2.3


From 06af73bd1d17b417f234746c9a2f8e8e92cf6149 Mon Sep 17 00:00:00 2001
From: AUTOMATIC1111 <16777216c@gmail.com>
Date: Sat, 9 Sep 2023 10:23:53 +0300
Subject: linter

---
 modules/scripts.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index f1f17a5f..5c6e0226 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -498,7 +498,7 @@ class ScriptRunner:
 
             choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
             if choices is not None:
-                setattr(arg_info, 'choices', [x[0] if isinstance(x, tuple) else x for x in choices])
+                arg_info.choices = [x[0] if isinstance(x, tuple) else x for x in choices]
 
             api_args.append(arg_info)
 
-- 
cgit v1.2.3


From 0fc7dc1c04a046d95588651ffc4e71a7d40378d3 Mon Sep 17 00:00:00 2001
From: wfjsw <wfjsw@users.noreply.github.com>
Date: Sat, 11 Nov 2023 04:01:13 -0600
Subject: implementing script metadata and DAG sorting mechanism

---
 modules/scripts.py | 141 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 126 insertions(+), 15 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 5c6e0226..e92a34a0 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -2,6 +2,7 @@ import os
 import re
 import sys
 import inspect
+from graphlib import TopologicalSorter, CycleError
 from collections import namedtuple
 from dataclasses import dataclass
 
@@ -314,15 +315,131 @@ ScriptClassData = namedtuple("ScriptClassData", ["script_class", "path", "basedi
 
 def list_scripts(scriptdirname, extension, *, include_extensions=True):
     scripts_list = []
-
-    basedir = os.path.join(paths.script_path, scriptdirname)
-    if os.path.exists(basedir):
-        for filename in sorted(os.listdir(basedir)):
-            scripts_list.append(ScriptFile(paths.script_path, filename, os.path.join(basedir, filename)))
+    script_dependency_map = {}
+
+    # build script dependency map
+
+    root_script_basedir = os.path.join(paths.script_path, scriptdirname)
+    if os.path.exists(root_script_basedir):
+        for filename in sorted(os.listdir(root_script_basedir)):
+            script_dependency_map[filename] = {
+                "extension": None,
+                "extension_dirname": None,
+                "script_file": ScriptFile(paths.script_path, filename, os.path.join(root_script_basedir, filename)),
+                "requires": [],
+                "load_before": [],
+                "load_after": [],
+            }
 
     if include_extensions:
         for ext in extensions.active():
-            scripts_list += ext.list_files(scriptdirname, extension)
+            extension_scripts_list = ext.list_files(scriptdirname, extension)
+            for extension_script in extension_scripts_list:
+                # this is built on the assumption that script name is unique.
+                # I think bad thing is gonna happen if name collide in the current implementation anyway, but we
+                # will need to refactor here if this assumption is broken later on.
+                if extension_script.filename in script_dependency_map:
+                    errors.report(f"Duplicate script name \"{extension_script.filename}\" found in extensions "
+                                  f"\"{ext.name}\" and \"{script_dependency_map[extension_script.filename]['extension_dirname'] or 'builtin'}\". "
+                                  f"The current loading file will be discarded.", exc_info=False)
+                    continue
+
+                relative_path = scriptdirname + "/" + extension_script.filename
+
+                requires = None
+                load_before = None
+                load_after = None
+
+                if ext.metadata is not None:
+                    requires = ext.metadata.get(relative_path, "Requires", fallback=None)
+                    load_before = ext.metadata.get(relative_path, "Before", fallback=None)
+                    load_after = ext.metadata.get(relative_path, "After", fallback=None)
+
+                requires = [x.strip() for x in requires.split(',')] if requires else []
+                load_after = [x.strip() for x in load_after.split(',')] if load_after else []
+                load_before = [x.strip() for x in load_before.split(',')] if load_before else []
+
+                script_dependency_map[extension_script.filename] = {
+                    "extension": ext.canonical_name,
+                    "extension_dirname": ext.name,
+                    "script_file": extension_script,
+                    "requires": requires,
+                    "load_before": load_before,
+                    "load_after": load_after,
+                }
+
+    # resolve dependencies
+
+    loaded_extensions = set()
+    for _, script_data in script_dependency_map.items():
+        if script_data['extension'] is not None:
+            loaded_extensions.add(script_data['extension'])
+
+    for script_filename, script_data in script_dependency_map.items():
+        # load before requires inverse dependency
+        # in this case, append the script name into the load_after list of the specified script
+        for load_before_script in script_data['load_before']:
+            if load_before_script.startswith('ext:'):
+                # if this requires an extension to be loaded before
+                required_extension = load_before_script[4:]
+                for _, script_data2 in script_dependency_map.items():
+                    if script_data2['extension'] == required_extension:
+                        script_data2['load_after'].append(script_filename)
+                        break
+            else:
+                # if this requires an individual script to be loaded before
+                if load_before_script in script_dependency_map:
+                    script_dependency_map[load_before_script]['load_after'].append(script_filename)
+
+        # resolve extension name in load_after lists
+        for load_after_script in script_data['load_after']:
+            if load_after_script.startswith('ext:'):
+                # if this requires an extension to be loaded after
+                required_extension = load_after_script[4:]
+                for script_file_name2, script_data2 in script_dependency_map.items():
+                    if script_data2['extension'] == required_extension:
+                        script_data['load_after'].append(script_file_name2)
+
+        # remove all extension names in load_after lists
+        script_data['load_after'] = [x for x in script_data['load_after'] if not x.startswith('ext:')]
+
+    # build the DAG
+    sorter = TopologicalSorter()
+    for script_filename, script_data in script_dependency_map.items():
+        requirement_met = True
+        for required_script in script_data['requires']:
+            if required_script.startswith('ext:'):
+                # if this requires an extension to be installed
+                required_extension = required_script[4:]
+                if required_extension not in loaded_extensions:
+                    errors.report(f"Script \"{script_filename}\" requires extension \"{required_extension}\" to "
+                                  f"be loaded, but it is not. Skipping.",
+                                  exc_info=False)
+                    requirement_met = False
+                    break
+            else:
+                # if this requires an individual script to be loaded
+                if required_script not in script_dependency_map:
+                    errors.report(f"Script \"{script_filename}\" requires script \"{required_script}\" to "
+                                  f"be loaded, but it is not. Skipping.",
+                                  exc_info=False)
+                    requirement_met = False
+                    break
+        if not requirement_met:
+            continue
+
+        sorter.add(script_filename, *script_data['load_after'])
+
+    # sort the scripts
+    try:
+        ordered_script = sorter.static_order()
+    except CycleError:
+        errors.report("Cycle detected in script dependencies. Scripts will load in ascending order.", exc_info=True)
+        ordered_script = script_dependency_map.keys()
+
+    for script_filename in ordered_script:
+        script_data = script_dependency_map[script_filename]
+        scripts_list.append(script_data['script_file'])
 
     scripts_list = [x for x in scripts_list if os.path.splitext(x.path)[1].lower() == extension and os.path.isfile(x.path)]
 
@@ -365,15 +482,9 @@ def load_scripts():
             elif issubclass(script_class, scripts_postprocessing.ScriptPostprocessing):
                 postprocessing_scripts_data.append(ScriptClassData(script_class, scriptfile.path, scriptfile.basedir, module))
 
-    def orderby(basedir):
-        # 1st webui, 2nd extensions-builtin, 3rd extensions
-        priority = {os.path.join(paths.script_path, "extensions-builtin"):1, paths.script_path:0}
-        for key in priority:
-            if basedir.startswith(key):
-                return priority[key]
-        return 9999
-
-    for scriptfile in sorted(scripts_list, key=lambda x: [orderby(x.basedir), x]):
+    # here the scripts_list is already ordered
+    # processing_script is not considered though
+    for scriptfile in scripts_list:
         try:
             if scriptfile.basedir != paths.script_path:
                 sys.path = [scriptfile.basedir] + sys.path
-- 
cgit v1.2.3


From 0d1924c48be3d02650e87b12a4f53165a8b4a599 Mon Sep 17 00:00:00 2001
From: wfjsw <wfjsw@users.noreply.github.com>
Date: Sat, 11 Nov 2023 04:03:55 -0600
Subject: populate loaded_extensions from extension list instead

---
 modules/scripts.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index e92a34a0..7cdf288d 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -371,9 +371,8 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
     # resolve dependencies
 
     loaded_extensions = set()
-    for _, script_data in script_dependency_map.items():
-        if script_data['extension'] is not None:
-            loaded_extensions.add(script_data['extension'])
+    for ext in extensions.active():
+        loaded_extensions.add(ext.canonical_name)
 
     for script_filename, script_data in script_dependency_map.items():
         # load before requires inverse dependency
-- 
cgit v1.2.3


From 7af576e745c79a9539e40bc158e695192ae79f25 Mon Sep 17 00:00:00 2001
From: wfjsw <wfjsw@users.noreply.github.com>
Date: Sat, 11 Nov 2023 10:46:47 -0600
Subject: remove the assumption of same name

---
 modules/scripts.py | 81 ++++++++++++++++++++----------------------------------
 1 file changed, 30 insertions(+), 51 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 7cdf288d..7ad22245 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -335,15 +335,9 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
         for ext in extensions.active():
             extension_scripts_list = ext.list_files(scriptdirname, extension)
             for extension_script in extension_scripts_list:
-                # this is built on the assumption that script name is unique.
-                # I think bad thing is gonna happen if name collide in the current implementation anyway, but we
-                # will need to refactor here if this assumption is broken later on.
-                if extension_script.filename in script_dependency_map:
-                    errors.report(f"Duplicate script name \"{extension_script.filename}\" found in extensions "
-                                  f"\"{ext.name}\" and \"{script_dependency_map[extension_script.filename]['extension_dirname'] or 'builtin'}\". "
-                                  f"The current loading file will be discarded.", exc_info=False)
-                    continue
-
+                script_canonical_name = ext.canonical_name + "/" + extension_script.filename
+                if ext.is_builtin:
+                    script_canonical_name = "builtin/" + script_canonical_name
                 relative_path = scriptdirname + "/" + extension_script.filename
 
                 requires = None
@@ -359,7 +353,7 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
                 load_after = [x.strip() for x in load_after.split(',')] if load_after else []
                 load_before = [x.strip() for x in load_before.split(',')] if load_before else []
 
-                script_dependency_map[extension_script.filename] = {
+                script_dependency_map[script_canonical_name] = {
                     "extension": ext.canonical_name,
                     "extension_dirname": ext.name,
                     "script_file": extension_script,
@@ -374,60 +368,45 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
     for ext in extensions.active():
         loaded_extensions.add(ext.canonical_name)
 
-    for script_filename, script_data in script_dependency_map.items():
+    for script_canonical_name, script_data in script_dependency_map.items():
         # load before requires inverse dependency
         # in this case, append the script name into the load_after list of the specified script
         for load_before_script in script_data['load_before']:
-            if load_before_script.startswith('ext:'):
-                # if this requires an extension to be loaded before
-                required_extension = load_before_script[4:]
+            # if this requires an individual script to be loaded before
+            if load_before_script in script_dependency_map:
+                script_dependency_map[load_before_script]['load_after'].append(script_canonical_name)
+            elif load_before_script in loaded_extensions:
                 for _, script_data2 in script_dependency_map.items():
-                    if script_data2['extension'] == required_extension:
-                        script_data2['load_after'].append(script_filename)
+                    if script_data2['extension'] == load_before_script:
+                        script_data2['load_after'].append(script_canonical_name)
                         break
-            else:
-                # if this requires an individual script to be loaded before
-                if load_before_script in script_dependency_map:
-                    script_dependency_map[load_before_script]['load_after'].append(script_filename)
 
         # resolve extension name in load_after lists
-        for load_after_script in script_data['load_after']:
-            if load_after_script.startswith('ext:'):
-                # if this requires an extension to be loaded after
-                required_extension = load_after_script[4:]
-                for script_file_name2, script_data2 in script_dependency_map.items():
-                    if script_data2['extension'] == required_extension:
-                        script_data['load_after'].append(script_file_name2)
-
-        # remove all extension names in load_after lists
-        script_data['load_after'] = [x for x in script_data['load_after'] if not x.startswith('ext:')]
+        for load_after_script in list(script_data['load_after']):
+            if load_after_script not in script_dependency_map and load_after_script in loaded_extensions:
+                script_data['load_after'].remove(load_after_script)
+                for script_canonical_name2, script_data2 in script_dependency_map.items():
+                    if script_data2['extension'] == load_after_script:
+                        script_data['load_after'].remove(script_canonical_name2)
+                        break
 
     # build the DAG
     sorter = TopologicalSorter()
-    for script_filename, script_data in script_dependency_map.items():
+    for script_canonical_name, script_data in script_dependency_map.items():
         requirement_met = True
         for required_script in script_data['requires']:
-            if required_script.startswith('ext:'):
-                # if this requires an extension to be installed
-                required_extension = required_script[4:]
-                if required_extension not in loaded_extensions:
-                    errors.report(f"Script \"{script_filename}\" requires extension \"{required_extension}\" to "
-                                  f"be loaded, but it is not. Skipping.",
-                                  exc_info=False)
-                    requirement_met = False
-                    break
-            else:
-                # if this requires an individual script to be loaded
-                if required_script not in script_dependency_map:
-                    errors.report(f"Script \"{script_filename}\" requires script \"{required_script}\" to "
-                                  f"be loaded, but it is not. Skipping.",
-                                  exc_info=False)
-                    requirement_met = False
-                    break
+            # if this requires an individual script to be loaded
+            if required_script not in script_dependency_map and required_script not in loaded_extensions:
+                errors.report(f"Script \"{script_canonical_name}\" "
+                              f"requires \"{required_script}\" to "
+                              f"be loaded, but it is not. Skipping.",
+                              exc_info=False)
+                requirement_met = False
+                break
         if not requirement_met:
             continue
 
-        sorter.add(script_filename, *script_data['load_after'])
+        sorter.add(script_canonical_name, *script_data['load_after'])
 
     # sort the scripts
     try:
@@ -436,8 +415,8 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
         errors.report("Cycle detected in script dependencies. Scripts will load in ascending order.", exc_info=True)
         ordered_script = script_dependency_map.keys()
 
-    for script_filename in ordered_script:
-        script_data = script_dependency_map[script_filename]
+    for script_canonical_name in ordered_script:
+        script_data = script_dependency_map[script_canonical_name]
         scripts_list.append(script_data['script_file'])
 
     scripts_list = [x for x in scripts_list if os.path.splitext(x.path)[1].lower() == extension and os.path.isfile(x.path)]
-- 
cgit v1.2.3


From 520e52f846892cc2b207b738b4180fa863c7b38f Mon Sep 17 00:00:00 2001
From: wfjsw <wfjsw@users.noreply.github.com>
Date: Sat, 11 Nov 2023 10:58:26 -0600
Subject: allow comma and whitespace as separator

---
 modules/scripts.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 7ad22245..5dd0555d 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -349,9 +349,9 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
                     load_before = ext.metadata.get(relative_path, "Before", fallback=None)
                     load_after = ext.metadata.get(relative_path, "After", fallback=None)
 
-                requires = [x.strip() for x in requires.split(',')] if requires else []
-                load_after = [x.strip() for x in load_after.split(',')] if load_after else []
-                load_before = [x.strip() for x in load_before.split(',')] if load_before else []
+                requires = list(filter(None, re.split(r"[,\s]+", requires.lower()))) if requires else []
+                load_after = list(filter(None, re.split(r"[,\s]+", load_after.lower()))) if load_after else []
+                load_before = list(filter(None, re.split(r"[,\s]+", load_before.lower()))) if load_before else []
 
                 script_dependency_map[script_canonical_name] = {
                     "extension": ext.canonical_name,
-- 
cgit v1.2.3


From 3bb32befe9523a6acefbab7fe099f91660f41ea9 Mon Sep 17 00:00:00 2001
From: wfjsw <wfjsw@users.noreply.github.com>
Date: Sat, 11 Nov 2023 11:58:19 -0600
Subject: bug fix

---
 modules/scripts.py | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 5dd0555d..b1f4504a 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -322,6 +322,9 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
     root_script_basedir = os.path.join(paths.script_path, scriptdirname)
     if os.path.exists(root_script_basedir):
         for filename in sorted(os.listdir(root_script_basedir)):
+            if not os.path.isfile(os.path.join(root_script_basedir, filename)):
+                continue
+
             script_dependency_map[filename] = {
                 "extension": None,
                 "extension_dirname": None,
@@ -335,19 +338,27 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
         for ext in extensions.active():
             extension_scripts_list = ext.list_files(scriptdirname, extension)
             for extension_script in extension_scripts_list:
+                if not os.path.isfile(extension_script.path):
+                    continue
+
                 script_canonical_name = ext.canonical_name + "/" + extension_script.filename
                 if ext.is_builtin:
                     script_canonical_name = "builtin/" + script_canonical_name
                 relative_path = scriptdirname + "/" + extension_script.filename
 
-                requires = None
-                load_before = None
-                load_after = None
+                requires = ''
+                load_before = ''
+                load_after = ''
 
                 if ext.metadata is not None:
-                    requires = ext.metadata.get(relative_path, "Requires", fallback=None)
-                    load_before = ext.metadata.get(relative_path, "Before", fallback=None)
-                    load_after = ext.metadata.get(relative_path, "After", fallback=None)
+                    requires = ext.metadata.get(relative_path, "Requires", fallback='')
+                    load_before = ext.metadata.get(relative_path, "Before", fallback='')
+                    load_after = ext.metadata.get(relative_path, "After", fallback='')
+
+                    # propagate directory level metadata
+                    requires = requires + ',' + ext.metadata.get(scriptdirname, "Requires", fallback='')
+                    load_before = load_before + ',' + ext.metadata.get(scriptdirname, "Before", fallback='')
+                    load_after = load_after + ',' + ext.metadata.get(scriptdirname, "After", fallback='')
 
                 requires = list(filter(None, re.split(r"[,\s]+", requires.lower()))) if requires else []
                 load_after = list(filter(None, re.split(r"[,\s]+", load_after.lower()))) if load_after else []
@@ -387,7 +398,7 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
                 script_data['load_after'].remove(load_after_script)
                 for script_canonical_name2, script_data2 in script_dependency_map.items():
                     if script_data2['extension'] == load_after_script:
-                        script_data['load_after'].remove(script_canonical_name2)
+                        script_data['load_after'].append(script_canonical_name2)
                         break
 
     # build the DAG
-- 
cgit v1.2.3


From 9b471436b2226458a767077707ea102e331b5d78 Mon Sep 17 00:00:00 2001
From: AUTOMATIC1111 <16777216c@gmail.com>
Date: Mon, 20 Nov 2023 14:47:09 +0300
Subject: rework extensions metadata: use custom sorter that doesn't mess the
 order as much and ignores cyclic errors, use classes with named fields
 instead of dictionaries, eliminate some duplicated code

---
 modules/scripts.py | 169 +++++++++++++++++++++++++----------------------------
 1 file changed, 78 insertions(+), 91 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index b1f4504a..b0689a23 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -2,7 +2,6 @@ import os
 import re
 import sys
 import inspect
-from graphlib import TopologicalSorter, CycleError
 from collections import namedtuple
 from dataclasses import dataclass
 
@@ -312,27 +311,57 @@ scripts_data = []
 postprocessing_scripts_data = []
 ScriptClassData = namedtuple("ScriptClassData", ["script_class", "path", "basedir", "module"])
 
+def topological_sort(dependencies):
+    """Accepts a dictionary mapping name to its dependencies, returns a list of names ordered according to dependencies.
+    Ignores errors relating to missing dependeencies or circular dependencies
+    """
+
+    visited = {}
+    result = []
+
+    def inner(name):
+        visited[name] = True
+
+        for dep in dependencies.get(name, []):
+            if dep in dependencies and dep not in visited:
+                inner(dep)
+
+        result.append(name)
+
+    for depname in dependencies:
+        if depname not in visited:
+            inner(depname)
+
+    return result
+
+
+@dataclass
+class ScriptWithDependencies:
+    script_canonical_name: str
+    file: ScriptFile
+    requires: list
+    load_before: list
+    load_after: list
+
 
 def list_scripts(scriptdirname, extension, *, include_extensions=True):
-    scripts_list = []
-    script_dependency_map = {}
+    scripts = {}
 
-    # build script dependency map
+    loaded_extensions = {ext.canonical_name: ext for ext in extensions.active()}
+    loaded_extensions_scripts = {ext.canonical_name: [] for ext in extensions.active()}
 
+    # build script dependency map
     root_script_basedir = os.path.join(paths.script_path, scriptdirname)
     if os.path.exists(root_script_basedir):
         for filename in sorted(os.listdir(root_script_basedir)):
             if not os.path.isfile(os.path.join(root_script_basedir, filename)):
                 continue
 
-            script_dependency_map[filename] = {
-                "extension": None,
-                "extension_dirname": None,
-                "script_file": ScriptFile(paths.script_path, filename, os.path.join(root_script_basedir, filename)),
-                "requires": [],
-                "load_before": [],
-                "load_after": [],
-            }
+            if os.path.splitext(filename)[1].lower() != extension:
+                continue
+
+            script_file = ScriptFile(paths.script_path, filename, os.path.join(root_script_basedir, filename))
+            scripts[filename] = ScriptWithDependencies(filename, script_file, [], [], [])
 
     if include_extensions:
         for ext in extensions.active():
@@ -341,96 +370,54 @@ def list_scripts(scriptdirname, extension, *, include_extensions=True):
                 if not os.path.isfile(extension_script.path):
                     continue
 
-                script_canonical_name = ext.canonical_name + "/" + extension_script.filename
-                if ext.is_builtin:
-                    script_canonical_name = "builtin/" + script_canonical_name
+                script_canonical_name = ("builtin/" if ext.is_builtin else "") + ext.canonical_name + "/" + extension_script.filename
                 relative_path = scriptdirname + "/" + extension_script.filename
 
-                requires = ''
-                load_before = ''
-                load_after = ''
-
-                if ext.metadata is not None:
-                    requires = ext.metadata.get(relative_path, "Requires", fallback='')
-                    load_before = ext.metadata.get(relative_path, "Before", fallback='')
-                    load_after = ext.metadata.get(relative_path, "After", fallback='')
-
-                    # propagate directory level metadata
-                    requires = requires + ',' + ext.metadata.get(scriptdirname, "Requires", fallback='')
-                    load_before = load_before + ',' + ext.metadata.get(scriptdirname, "Before", fallback='')
-                    load_after = load_after + ',' + ext.metadata.get(scriptdirname, "After", fallback='')
-
-                requires = list(filter(None, re.split(r"[,\s]+", requires.lower()))) if requires else []
-                load_after = list(filter(None, re.split(r"[,\s]+", load_after.lower()))) if load_after else []
-                load_before = list(filter(None, re.split(r"[,\s]+", load_before.lower()))) if load_before else []
-
-                script_dependency_map[script_canonical_name] = {
-                    "extension": ext.canonical_name,
-                    "extension_dirname": ext.name,
-                    "script_file": extension_script,
-                    "requires": requires,
-                    "load_before": load_before,
-                    "load_after": load_after,
-                }
+                script = ScriptWithDependencies(
+                    script_canonical_name=script_canonical_name,
+                    file=extension_script,
+                    requires=ext.metadata.get_script_requirements("Requires", relative_path, scriptdirname),
+                    load_before=ext.metadata.get_script_requirements("Before", relative_path, scriptdirname),
+                    load_after=ext.metadata.get_script_requirements("After", relative_path, scriptdirname),
+                )
 
-    # resolve dependencies
+                scripts[script_canonical_name] = script
+                loaded_extensions_scripts[ext.canonical_name].append(script)
 
-    loaded_extensions = set()
-    for ext in extensions.active():
-        loaded_extensions.add(ext.canonical_name)
-
-    for script_canonical_name, script_data in script_dependency_map.items():
+    for script_canonical_name, script in scripts.items():
         # load before requires inverse dependency
         # in this case, append the script name into the load_after list of the specified script
-        for load_before_script in script_data['load_before']:
+        for load_before in script.load_before:
             # if this requires an individual script to be loaded before
-            if load_before_script in script_dependency_map:
-                script_dependency_map[load_before_script]['load_after'].append(script_canonical_name)
-            elif load_before_script in loaded_extensions:
-                for _, script_data2 in script_dependency_map.items():
-                    if script_data2['extension'] == load_before_script:
-                        script_data2['load_after'].append(script_canonical_name)
-                        break
-
-        # resolve extension name in load_after lists
-        for load_after_script in list(script_data['load_after']):
-            if load_after_script not in script_dependency_map and load_after_script in loaded_extensions:
-                script_data['load_after'].remove(load_after_script)
-                for script_canonical_name2, script_data2 in script_dependency_map.items():
-                    if script_data2['extension'] == load_after_script:
-                        script_data['load_after'].append(script_canonical_name2)
-                        break
-
-    # build the DAG
-    sorter = TopologicalSorter()
-    for script_canonical_name, script_data in script_dependency_map.items():
-        requirement_met = True
-        for required_script in script_data['requires']:
-            # if this requires an individual script to be loaded
-            if required_script not in script_dependency_map and required_script not in loaded_extensions:
-                errors.report(f"Script \"{script_canonical_name}\" "
-                              f"requires \"{required_script}\" to "
-                              f"be loaded, but it is not. Skipping.",
-                              exc_info=False)
-                requirement_met = False
-                break
-        if not requirement_met:
-            continue
+            other_script = scripts.get(load_before)
+            if other_script:
+                other_script.load_after.append(script_canonical_name)
 
-        sorter.add(script_canonical_name, *script_data['load_after'])
+            # if this requires an extension
+            other_extension_scripts = loaded_extensions_scripts.get(load_before)
+            if other_extension_scripts:
+                for other_script in other_extension_scripts:
+                    other_script.load_after.append(script_canonical_name)
 
-    # sort the scripts
-    try:
-        ordered_script = sorter.static_order()
-    except CycleError:
-        errors.report("Cycle detected in script dependencies. Scripts will load in ascending order.", exc_info=True)
-        ordered_script = script_dependency_map.keys()
+        # if After mentions an extension, remove it and instead add all of its scripts
+        for load_after in list(script.load_after):
+            if load_after not in scripts and load_after in loaded_extensions_scripts:
+                script.load_after.remove(load_after)
+
+                for other_script in loaded_extensions_scripts.get(load_after, []):
+                    script.load_after.append(other_script.script_canonical_name)
+
+    dependencies = {}
+
+    for script_canonical_name, script in scripts.items():
+        for required_script in script.requires:
+            if required_script not in scripts and required_script not in loaded_extensions:
+                errors.report(f'Script "{script_canonical_name}" requires "{required_script}" to be loaded, but it is not.', exc_info=False)
 
-    for script_canonical_name in ordered_script:
-        script_data = script_dependency_map[script_canonical_name]
-        scripts_list.append(script_data['script_file'])
+        dependencies[script_canonical_name] = script.load_after
 
-    scripts_list = [x for x in scripts_list if os.path.splitext(x.path)[1].lower() == extension and os.path.isfile(x.path)]
+    ordered_scripts = topological_sort(dependencies)
+    scripts_list = [scripts[script_canonical_name].file for script_canonical_name in ordered_scripts]
 
     return scripts_list
 
-- 
cgit v1.2.3


From 8a6e4bda21dddef3ab2e70a05d71b587b6c8b04b Mon Sep 17 00:00:00 2001
From: w-e-w <40751091+w-e-w@users.noreply.github.com>
Date: Mon, 27 Nov 2023 14:00:17 +0900
Subject: catch uncaught exception with ui creation scripts

prevent total webui crash
---
 modules/scripts.py | 54 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 29 insertions(+), 25 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index b0689a23..961d032c 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -570,40 +570,44 @@ class ScriptRunner:
         if controls is None:
             return
 
-        script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
-        api_args = []
+        try:
+            script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
+            api_args = []
 
-        for control in controls:
-            control.custom_script_source = os.path.basename(script.filename)
+            for control in controls:
+                control.custom_script_source = os.path.basename(script.filename)
 
-            arg_info = api_models.ScriptArg(label=control.label or "")
+                arg_info = api_models.ScriptArg(label=control.label or "")
 
-            for field in ("value", "minimum", "maximum", "step"):
-                v = getattr(control, field, None)
-                if v is not None:
-                    setattr(arg_info, field, v)
+                for field in ("value", "minimum", "maximum", "step"):
+                    v = getattr(control, field, None)
+                    if v is not None:
+                        setattr(arg_info, field, v)
 
-            choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
-            if choices is not None:
-                arg_info.choices = [x[0] if isinstance(x, tuple) else x for x in choices]
+                choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
+                if choices is not None:
+                    arg_info.choices = [x[0] if isinstance(x, tuple) else x for x in choices]
 
-            api_args.append(arg_info)
+                api_args.append(arg_info)
 
-        script.api_info = api_models.ScriptInfo(
-            name=script.name,
-            is_img2img=script.is_img2img,
-            is_alwayson=script.alwayson,
-            args=api_args,
-        )
+            script.api_info = api_models.ScriptInfo(
+                name=script.name,
+                is_img2img=script.is_img2img,
+                is_alwayson=script.alwayson,
+                args=api_args,
+            )
 
-        if script.infotext_fields is not None:
-            self.infotext_fields += script.infotext_fields
+            if script.infotext_fields is not None:
+                self.infotext_fields += script.infotext_fields
 
-        if script.paste_field_names is not None:
-            self.paste_field_names += script.paste_field_names
+            if script.paste_field_names is not None:
+                self.paste_field_names += script.paste_field_names
 
-        self.inputs += controls
-        script.args_to = len(self.inputs)
+            self.inputs += controls
+            script.args_to = len(self.inputs)
+
+        except Exception:
+            errors.report(f"Error creating UI for {script.name}: ", exc_info=True)
 
     def setup_ui_for_section(self, section, scriptlist=None):
         if scriptlist is None:
-- 
cgit v1.2.3


From ef6b8123dc57e4e4bd5e08d9f3e3dbdfdf6b4c4a Mon Sep 17 00:00:00 2001
From: AUTOMATIC1111 <16777216c@gmail.com>
Date: Sat, 2 Dec 2023 09:57:39 +0300
Subject: put code that can cause an exception into its own function for #14120

---
 modules/scripts.py | 62 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 33 insertions(+), 29 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 961d032c..7f9454eb 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -560,54 +560,58 @@ class ScriptRunner:
             on_after.clear()
 
     def create_script_ui(self, script):
-        import modules.api.models as api_models
 
         script.args_from = len(self.inputs)
         script.args_to = len(self.inputs)
 
+        try:
+            self.create_script_ui_inner(script)
+        except Exception:
+            errors.report(f"Error creating UI for {script.name}: ", exc_info=True)
+
+    def create_script_ui_inner(self, script):
+        import modules.api.models as api_models
+
         controls = wrap_call(script.ui, script.filename, "ui", script.is_img2img)
 
         if controls is None:
             return
 
-        try:
-            script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
-            api_args = []
+        script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
 
-            for control in controls:
-                control.custom_script_source = os.path.basename(script.filename)
+        api_args = []
 
-                arg_info = api_models.ScriptArg(label=control.label or "")
+        for control in controls:
+            control.custom_script_source = os.path.basename(script.filename)
 
-                for field in ("value", "minimum", "maximum", "step"):
-                    v = getattr(control, field, None)
-                    if v is not None:
-                        setattr(arg_info, field, v)
+            arg_info = api_models.ScriptArg(label=control.label or "")
 
-                choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
-                if choices is not None:
-                    arg_info.choices = [x[0] if isinstance(x, tuple) else x for x in choices]
+            for field in ("value", "minimum", "maximum", "step"):
+                v = getattr(control, field, None)
+                if v is not None:
+                    setattr(arg_info, field, v)
 
-                api_args.append(arg_info)
+            choices = getattr(control, 'choices', None)  # as of gradio 3.41, some items in choices are strings, and some are tuples where the first elem is the string
+            if choices is not None:
+                arg_info.choices = [x[0] if isinstance(x, tuple) else x for x in choices]
 
-            script.api_info = api_models.ScriptInfo(
-                name=script.name,
-                is_img2img=script.is_img2img,
-                is_alwayson=script.alwayson,
-                args=api_args,
-            )
+            api_args.append(arg_info)
 
-            if script.infotext_fields is not None:
-                self.infotext_fields += script.infotext_fields
+        script.api_info = api_models.ScriptInfo(
+            name=script.name,
+            is_img2img=script.is_img2img,
+            is_alwayson=script.alwayson,
+            args=api_args,
+        )
 
-            if script.paste_field_names is not None:
-                self.paste_field_names += script.paste_field_names
+        if script.infotext_fields is not None:
+            self.infotext_fields += script.infotext_fields
 
-            self.inputs += controls
-            script.args_to = len(self.inputs)
+        if script.paste_field_names is not None:
+            self.paste_field_names += script.paste_field_names
 
-        except Exception:
-            errors.report(f"Error creating UI for {script.name}: ", exc_info=True)
+        self.inputs += controls
+        script.args_to = len(self.inputs)
 
     def setup_ui_for_section(self, section, scriptlist=None):
         if scriptlist is None:
-- 
cgit v1.2.3


From ac4578912395627731f2cd8529f87a95df1f7644 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Wed, 6 Dec 2023 21:16:27 -0700
Subject: Removed soft inpainting, added hooks for softpainting to work
 instead.

---
 modules/scripts.py | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 7f9454eb..92a07c56 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -11,11 +11,31 @@ from modules import shared, paths, script_callbacks, extensions, script_loading,
 
 AlwaysVisible = object()
 
+class MaskBlendArgs:
+    def __init__(self, current_latent, nmask, init_latent, mask, blended_samples, denoiser=None, sigma=None):
+        self.current_latent = current_latent
+        self.nmask = nmask
+        self.init_latent = init_latent
+        self.mask = mask
+        self.blended_samples = blended_samples
+
+        self.denoiser = denoiser
+        self.is_final_blend = denoiser is None
+        self.sigma = sigma
+
+class PostSampleArgs:
+    def __init__(self, samples):
+        self.samples = samples
 
 class PostprocessImageArgs:
     def __init__(self, image):
         self.image = image
 
+class PostProcessMaskOverlayArgs:
+    def __init__(self, index, mask_for_overlay, overlay_image):
+        self.index = index
+        self.mask_for_overlay = mask_for_overlay
+        self.overlay_image = overlay_image
 
 class PostprocessBatchListArgs:
     def __init__(self, images):
@@ -206,6 +226,25 @@ class Script:
 
         pass
 
+    def on_mask_blend(self, p, mba: MaskBlendArgs, *args):
+        """
+        Called in inpainting mode when the original content is blended with the inpainted content.
+        This is called at every step in the denoising process and once at the end.
+        If is_final_blend is true, this is called for the final blending stage.
+        Otherwise, denoiser and sigma are defined and may be used to inform the procedure.
+        """
+
+        pass
+
+    def post_sample(self, p, ps: PostSampleArgs, *args):
+        """
+        Called after the samples have been generated,
+        but before they have been decoded by the VAE, if applicable.
+        Check getattr(samples, 'already_decoded', False) to test if the images are decoded.
+        """
+
+        pass
+
     def postprocess_image(self, p, pp: PostprocessImageArgs, *args):
         """
         Called for every image after it has been generated.
@@ -213,6 +252,13 @@ class Script:
 
         pass
 
+    def postprocess_maskoverlay(self, p, ppmo: PostProcessMaskOverlayArgs, *args):
+        """
+        Called for every image after it has been generated.
+        """
+
+        pass
+
     def postprocess(self, p, processed, *args):
         """
         This function is called after processing ends for AlwaysVisible scripts.
@@ -767,6 +813,22 @@ class ScriptRunner:
             except Exception:
                 errors.report(f"Error running postprocess_batch_list: {script.filename}", exc_info=True)
 
+    def post_sample(self, p, ps: PostSampleArgs):
+        for script in self.alwayson_scripts:
+            try:
+                script_args = p.script_args[script.args_from:script.args_to]
+                script.post_sample(p, ps, *script_args)
+            except Exception:
+                errors.report(f"Error running post_sample: {script.filename}", exc_info=True)
+
+    def on_mask_blend(self, p, mba: MaskBlendArgs):
+        for script in self.alwayson_scripts:
+            try:
+                script_args = p.script_args[script.args_from:script.args_to]
+                script.on_mask_blend(p, mba, *script_args)
+            except Exception:
+                errors.report(f"Error running post_sample: {script.filename}", exc_info=True)
+
     def postprocess_image(self, p, pp: PostprocessImageArgs):
         for script in self.alwayson_scripts:
             try:
@@ -775,6 +837,14 @@ class ScriptRunner:
             except Exception:
                 errors.report(f"Error running postprocess_image: {script.filename}", exc_info=True)
 
+    def postprocess_maskoverlay(self, p, ppmo: PostProcessMaskOverlayArgs):
+        for script in self.alwayson_scripts:
+            try:
+                script_args = p.script_args[script.args_from:script.args_to]
+                script.postprocess_maskoverlay(p, ppmo, *script_args)
+            except Exception:
+                errors.report(f"Error running postprocess_image: {script.filename}", exc_info=True)
+
     def before_component(self, component, **kwargs):
         for callback, script in self.on_before_component_elem_id.get(kwargs.get("elem_id"), []):
             try:
-- 
cgit v1.2.3


From 2abc417834d752e43a283f8603bfddfb1c80b30f Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Wed, 6 Dec 2023 22:25:53 -0700
Subject: Re-implemented soft inpainting via a script. Also fixed some mistakes
 with the previous hooks, removed unnecessary formatting changes, removed code
 that I had forgotten to.

---
 modules/scripts.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'modules/scripts.py')

diff --git a/modules/scripts.py b/modules/scripts.py
index 92a07c56..b6fcf96e 100644
--- a/modules/scripts.py
+++ b/modules/scripts.py
@@ -12,12 +12,12 @@ from modules import shared, paths, script_callbacks, extensions, script_loading,
 AlwaysVisible = object()
 
 class MaskBlendArgs:
-    def __init__(self, current_latent, nmask, init_latent, mask, blended_samples, denoiser=None, sigma=None):
+    def __init__(self, current_latent, nmask, init_latent, mask, blended_latent, denoiser=None, sigma=None):
         self.current_latent = current_latent
         self.nmask = nmask
         self.init_latent = init_latent
         self.mask = mask
-        self.blended_samples = blended_samples
+        self.blended_latent = blended_latent
 
         self.denoiser = denoiser
         self.is_final_blend = denoiser is None
-- 
cgit v1.2.3