feat: samplers - support internal_seed

- Avoiding the issue where the GPU seed causes problems in ancestral mode.

https://github.com/comfyanonymous/ComfyUI/commit/916d1e14a93ef331adef7c0deff2fdcf443b05cf#commitcomment-151914788

README.md

@@ -2,6 +2,7 @@
 This repository offers various extension nodes for ComfyUI. Nodes here have different characteristics compared to those in the ComfyUI Impact Pack. The Impact Pack has become too large now...
 
 ## Notice:
+* v1.9.1 To avoid confusion with the `NOISE` type in core, the type name has been changed to `NOISE_IMAGE`.
 * V0.73 The Variation Seed feature is added to Regional Prompt nodes, and it is only compatible with versions Impact Pack V5.10 and above.
 * V0.69 incompatible with the outdated **ComfyUI IPAdapter Plus**. (A version dated March 24th or later is required.)
 * V0.64 add sigma_factor to RegionalPrompt... nodes required Impact Pack V4.76 or later.
@@ -62,9 +63,15 @@ This repository offers various extension nodes for ComfyUI. Nodes here have diff
     * Specify the directories located under `ComfyUI-Inspire-Pack/prompts/`
     * One prompts file can have multiple prompts separated by `---`. 
     * e.g. `prompts/example`
-  * `Load Prompts From File (Inspire)`: It sequentially reads prompts from the specified file. The output it returns is ZIPPED_PROMPT.
+    * **NOTE**: This node provides advanced option via `Show advanced`
+      * load_cap, start_index
+
+    * `Load Prompts From File (Inspire)`: It sequentially reads prompts from the specified file. The output it returns is ZIPPED_PROMPT.
     * Specify the file located under `ComfyUI-Inspire-Pack/prompts/`
     * e.g. `prompts/example/prompt2.txt`
+    * **NOTE**: This node provides advanced option via `Show advanced`
+      * load_cap, start_index
+
   * `Load Single Prompt From File (Inspire)`: Loads a single prompt from a file containing multiple prompts by using an index.
   * The prompts file directory can be specified as `inspire_prompts` in `extra_model_paths.yaml`
   * `Unzip Prompt (Inspire)`: Separate ZIPPED_PROMPT into `positive`, `negative`, and name components. 
@@ -146,7 +153,11 @@ This repository offers various extension nodes for ComfyUI. Nodes here have diff
   * `Shared Checkpoint Loader (Inspire)`: When loading a checkpoint through this loader, it is automatically cached in the backend cache. Additionally, if it is already cached, it retrieves it from the cache instead of loading it anew.
     * When `key_opt` is empty, the `ckpt_name` is set as the cache key. The cache key output can be used for deletion purposes with Remove Back End.
     * This node resolves the issue of reloading checkpoints during workflow switching.
+  * `Shared Diffusion Model Loader (Inspire)`: Similar to the `Shared Checkpoint Loader (Inspire)` but used for loading Diffusion models instead of Checkpoints.
+  * `Shared Text Encoder Loader (Inspire)`: Similar to the `Shared Checkpoint Loader (Inspire)` but used for loading Text Encoder models instead of Checkpoints.
+    * This node also functions as a unified node for `CLIPLoader`, `DualCLIPLoader`, and `TripleCLIPLoader`. 
   * `Stable Cascade Checkpoint Loader (Inspire)`: This node provides a feature that allows you to load the `stage_b` and `stage_c` checkpoints of Stable Cascade at once, and it also provides a backend caching feature, optionally.
+  * `Is Cached (Inspire)`: Returns whether the cache exists.
 
 ### Conditioning - Nodes for conditionings
   * `Concat Conditionings with Multiplier (Inspire)`: Concatenating an arbitrary number of Conditionings while applying a multiplier for each Conditioning. The multiplier depends on `comfy_PoP`, so [comfy_PoP](https://github.com/picturesonpictures/comfy_PoP) must be installed.

__init__.py

@@ -7,7 +7,7 @@
 
 import importlib
 
-version_code = [1, 7]
+version_code = [1, 13]
 version_str = f"V{version_code[0]}.{version_code[1]}" + (f'.{version_code[2]}' if len(version_code) > 2 else '')
 print(f"### Loading: ComfyUI-Inspire-Pack ({version_str})")
 

inspire/a1111_compat.py

@@ -8,9 +8,13 @@ from .libs import common
 
 
 class Inspire_RandomNoise:
-    def __init__(self, seed, mode, incremental_seed_mode, variation_seed, variation_strength, variation_method="linear"):
+    def __init__(self, seed, mode, incremental_seed_mode, variation_seed, variation_strength, variation_method="linear", internal_seed=None):
         device = comfy.model_management.get_torch_device()
-        self.seed = seed
+        # HOTFIX: https://github.com/comfyanonymous/ComfyUI/commit/916d1e14a93ef331adef7c0deff2fdcf443b05cf#commitcomment-151914788
+        # seed value should be different with generated noise
+
+        self.seed = internal_seed
+        self.noise_seed = seed
         self.noise_device = "cpu" if mode == "CPU" else device
         self.incremental_seed_mode = incremental_seed_mode
         self.variation_seed = variation_seed
@@ -20,7 +24,7 @@ class Inspire_RandomNoise:
     def generate_noise(self, input_latent):
         latent_image = input_latent["samples"]
         batch_inds = input_latent["batch_index"] if "batch_index" in input_latent else None
-        noise = utils.prepare_noise(latent_image, self.seed, batch_inds, self.noise_device, self.incremental_seed_mode,
+        noise = utils.prepare_noise(latent_image, self.noise_seed, batch_inds, self.noise_device, self.incremental_seed_mode,
                                     variation_seed=self.variation_seed, variation_strength=self.variation_strength, variation_method=self.variation_method)
         return noise.cpu()
 
@@ -29,28 +33,34 @@ class RandomNoise:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": {
-                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed for the initial noise applied to the latent."}),
                     "noise_mode": (["GPU(=A1111)", "CPU"],),
                     "batch_seed_mode": (["incremental", "comfy", "variation str inc:0.01", "variation str inc:0.05"],),
                     "variation_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
                     "variation_strength": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
                     },
                 "optional":
-                    {"variation_method": (["linear", "slerp"],), }
+                    {
+                        "variation_method": (["linear", "slerp"],),
+                        "internal_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed used for generating noise in intermediate steps when using ancestral and SDE-based samplers.\nNOTE: If `noise_mode` is in GPU mode and `internal_seed` is the same as `seed`, the generated image may be distorted."}),
+                    }
                 }
 
     RETURN_TYPES = ("NOISE",)
     FUNCTION = "get_noise"
     CATEGORY = "InspirePack/a1111_compat"
 
-    def get_noise(self, noise_seed, noise_mode, batch_seed_mode, variation_seed, variation_strength, variation_method="linear"):
-        return (Inspire_RandomNoise(noise_seed, noise_mode, batch_seed_mode, variation_seed, variation_strength, variation_method=variation_method),)
+    def get_noise(self, noise_seed, noise_mode, batch_seed_mode, variation_seed, variation_strength, variation_method="linear", internal_seed=None):
+        if internal_seed is None:
+            internal_seed = noise_seed
+
+        return (Inspire_RandomNoise(noise_seed, noise_mode, batch_seed_mode, variation_seed, variation_strength, variation_method=variation_method, internal_seed=internal_seed),)
 
 
 def inspire_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent, denoise=1.0,
                      noise_mode="CPU", disable_noise=False, start_step=None, last_step=None, force_full_denoise=False,
                      incremental_seed_mode="comfy", variation_seed=None, variation_strength=None, noise=None, callback=None, variation_method="linear",
-                     scheduler_func=None):
+                     scheduler_func=None, internal_seed=None):
     device = comfy.model_management.get_torch_device()
     noise_device = "cpu" if noise_mode == "CPU" else device
     latent_image = latent["samples"]
@@ -80,9 +90,12 @@ def inspire_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive,
             start_step = advanced_steps - steps
             steps = advanced_steps
 
+    if internal_seed is None:
+        internal_seed = seed
+
     try:
         samples = common.impact_sampling(
-            model=model, add_noise=not disable_noise, seed=seed, steps=steps, cfg=cfg, sampler_name=sampler_name, scheduler=scheduler, positive=positive, negative=negative,
+            model=model, add_noise=not disable_noise, seed=internal_seed, steps=steps, cfg=cfg, sampler_name=sampler_name, scheduler=scheduler, positive=positive, negative=negative,
             latent_image=latent, start_at_step=start_step, end_at_step=last_step, return_with_leftover_noise=not force_full_denoise, noise=noise, callback=callback,
             scheduler_func=scheduler_func)
     except Exception as e:
@@ -90,7 +103,7 @@ def inspire_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive,
             print(f"[Inspire Pack] Impact Pack is outdated. (Cannot use GITS scheduler.)")
 
             samples = common.impact_sampling(
-                model=model, add_noise=not disable_noise, seed=seed, steps=steps, cfg=cfg, sampler_name=sampler_name, scheduler=scheduler, positive=positive, negative=negative,
+                model=model, add_noise=not disable_noise, seed=internal_seed, steps=steps, cfg=cfg, sampler_name=sampler_name, scheduler=scheduler, positive=positive, negative=negative,
                 latent_image=latent, start_at_step=start_step, end_at_step=last_step, return_with_leftover_noise=not force_full_denoise, noise=noise, callback=callback)
         else:
             raise e
@@ -103,7 +116,7 @@ class KSampler_inspire:
     def INPUT_TYPES(s):
         return {"required":
                     {"model": ("MODEL",),
-                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed for the initial noise applied to the latent."}),
                      "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                      "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
                      "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
@@ -121,6 +134,7 @@ class KSampler_inspire:
                     {
                         "variation_method": (["linear", "slerp"],),
                         "scheduler_func_opt": ("SCHEDULER_FUNC",),
+                        "internal_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed used for generating noise in intermediate steps when using ancestral and SDE-based samplers.\nNOTE: If `noise_mode` is in GPU mode and `internal_seed` is the same as `seed`, the generated image may be distorted."}),
                     }
                 }
 
@@ -131,10 +145,11 @@ class KSampler_inspire:
 
     @staticmethod
     def doit(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise, noise_mode,
-             batch_seed_mode="comfy", variation_seed=None, variation_strength=None, variation_method="linear", scheduler_func_opt=None):
+             batch_seed_mode="comfy", variation_seed=None, variation_strength=None, variation_method="linear", scheduler_func_opt=None,
+             internal_seed=None):
         return (inspire_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise, noise_mode,
                                  incremental_seed_mode=batch_seed_mode, variation_seed=variation_seed, variation_strength=variation_strength, variation_method=variation_method,
-                                 scheduler_func=scheduler_func_opt)[0], )
+                                 scheduler_func=scheduler_func_opt, internal_seed=internal_seed)[0], )
 
 
 class KSamplerAdvanced_inspire:
@@ -143,7 +158,7 @@ class KSamplerAdvanced_inspire:
         return {"required":
                     {"model": ("MODEL",),
                      "add_noise": ("BOOLEAN", {"default": True, "label_on": "enable", "label_off": "disable"}),
-                     "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed for the initial noise applied to the latent."}),
                      "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                      "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01}),
                      "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
@@ -162,8 +177,9 @@ class KSamplerAdvanced_inspire:
                 "optional":
                     {
                         "variation_method": (["linear", "slerp"],),
-                        "noise_opt": ("NOISE",),
+                        "noise_opt": ("NOISE_IMAGE",),
                         "scheduler_func_opt": ("SCHEDULER_FUNC",),
+                        "internal_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed used for generating noise in intermediate steps when using ancestral and SDE-based samplers.\nNOTE: If `noise_mode` is in GPU mode and `internal_seed` is the same as `seed`, the generated image may be distorted."}),
                     }
                 }
 
@@ -174,7 +190,7 @@ class KSamplerAdvanced_inspire:
 
     @staticmethod
     def sample(model, add_noise, noise_seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, start_at_step, end_at_step, noise_mode, return_with_leftover_noise,
-               denoise=1.0, batch_seed_mode="comfy", variation_seed=None, variation_strength=None, noise_opt=None, callback=None, variation_method="linear", scheduler_func_opt=None):
+               denoise=1.0, batch_seed_mode="comfy", variation_seed=None, variation_strength=None, noise_opt=None, callback=None, variation_method="linear", scheduler_func_opt=None, internal_seed=None):
         force_full_denoise = True
 
         if return_with_leftover_noise:
@@ -189,7 +205,7 @@ class KSamplerAdvanced_inspire:
                                 denoise=denoise, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step,
                                 force_full_denoise=force_full_denoise, noise_mode=noise_mode, incremental_seed_mode=batch_seed_mode,
                                 variation_seed=variation_seed, variation_strength=variation_strength, noise=noise_opt, callback=callback, variation_method=variation_method,
-                                scheduler_func=scheduler_func_opt)
+                                scheduler_func=scheduler_func_opt, internal_seed=internal_seed)
 
     def doit(self, *args, **kwargs):
         return (self.sample(*args, **kwargs)[0],)
@@ -200,7 +216,7 @@ class KSampler_inspire_pipe:
     def INPUT_TYPES(s):
         return {"required":
                     {"basic_pipe": ("BASIC_PIPE",),
-                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed for the initial noise applied to the latent."}),
                      "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                      "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
                      "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
@@ -215,6 +231,7 @@ class KSampler_inspire_pipe:
                 "optional":
                     {
                         "scheduler_func_opt": ("SCHEDULER_FUNC",),
+                        "internal_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed used for generating noise in intermediate steps when using ancestral and SDE-based samplers.\nNOTE: If `noise_mode` is in GPU mode and `internal_seed` is the same as `seed`, the generated image may be distorted."}),
                     }
                 }
 
@@ -224,10 +241,10 @@ class KSampler_inspire_pipe:
     CATEGORY = "InspirePack/a1111_compat"
 
     def sample(self, basic_pipe, seed, steps, cfg, sampler_name, scheduler, latent_image, denoise, noise_mode, batch_seed_mode="comfy",
-               variation_seed=None, variation_strength=None, scheduler_func_opt=None):
+               variation_seed=None, variation_strength=None, scheduler_func_opt=None, internal_seed=None):
         model, clip, vae, positive, negative = basic_pipe
         latent = inspire_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise, noise_mode, incremental_seed_mode=batch_seed_mode,
-                                  variation_seed=variation_seed, variation_strength=variation_strength, scheduler_func=scheduler_func_opt)[0]
+                                  variation_seed=variation_seed, variation_strength=variation_strength, scheduler_func=scheduler_func_opt, internal_seed=internal_seed)[0]
         return latent, vae
 
 
@@ -237,7 +254,7 @@ class KSamplerAdvanced_inspire_pipe:
         return {"required":
                     {"basic_pipe": ("BASIC_PIPE",),
                      "add_noise": ("BOOLEAN", {"default": True, "label_on": "enable", "label_off": "disable"}),
-                     "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed for the initial noise applied to the latent."}),
                      "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                      "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01}),
                      "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
@@ -253,8 +270,9 @@ class KSamplerAdvanced_inspire_pipe:
                      },
                 "optional":
                     {
-                        "noise_opt": ("NOISE",),
+                        "noise_opt": ("NOISE_IMAGE",),
                         "scheduler_func_opt": ("SCHEDULER_FUNC",),
+                        "internal_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "This is the seed used for generating noise in intermediate steps when using ancestral and SDE-based samplers.\nNOTE: If `noise_mode` is in GPU mode and `internal_seed` is the same as `seed`, the generated image may be distorted."}),
                     }
                 }
 
@@ -264,7 +282,7 @@ class KSamplerAdvanced_inspire_pipe:
     CATEGORY = "InspirePack/a1111_compat"
 
     def sample(self, basic_pipe, add_noise, noise_seed, steps, cfg, sampler_name, scheduler, latent_image, start_at_step, end_at_step, noise_mode, return_with_leftover_noise,
-               denoise=1.0, batch_seed_mode="comfy", variation_seed=None, variation_strength=None, noise_opt=None, scheduler_func_opt=None):
+               denoise=1.0, batch_seed_mode="comfy", variation_seed=None, variation_strength=None, noise_opt=None, scheduler_func_opt=None, internal_seed=None):
         model, clip, vae, positive, negative = basic_pipe
         latent = KSamplerAdvanced_inspire().sample(model=model, add_noise=add_noise, noise_seed=noise_seed,
                                                    steps=steps, cfg=cfg, sampler_name=sampler_name, scheduler=scheduler,
@@ -272,7 +290,8 @@ class KSamplerAdvanced_inspire_pipe:
                                                    start_at_step=start_at_step, end_at_step=end_at_step,
                                                    noise_mode=noise_mode, return_with_leftover_noise=return_with_leftover_noise,
                                                    denoise=denoise, batch_seed_mode=batch_seed_mode, variation_seed=variation_seed,
-                                                   variation_strength=variation_strength, noise_opt=noise_opt, scheduler_func_opt=scheduler_func_opt)[0]
+                                                   variation_strength=variation_strength, noise_opt=noise_opt, scheduler_func_opt=scheduler_func_opt,
+                                                   internal_seed=internal_seed)[0]
         return latent, vae
 
 

inspire/backend_support.py

@@ -1,5 +1,6 @@
 import json
 import os
+from .libs import common
 
 import folder_paths
 import nodes
@@ -7,6 +8,8 @@ from server import PromptServer
 
 from .libs.utils import TaggedCache, any_typ
 
+import logging
+
 root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 settings_file = os.path.join(root_dir, 'cache_settings.json')
 try:
@@ -400,6 +403,174 @@ class CheckpointLoaderSimpleShared(nodes.CheckpointLoaderSimple):
         return (None, cache_weak_hash(key))
 
 
+class LoadDiffusionModelShared(nodes.UNETLoader):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model_name": (folder_paths.get_filename_list("diffusion_models"), {"tooltip": "Diffusion Model Name"}),
+                              "weight_dtype": (["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],),
+                              "key_opt": ("STRING", {"multiline": False, "placeholder": "If empty, use 'model_name' as the key."}),
+                              "mode": (['Auto', 'Override Cache', 'Read Only'],),
+                              }
+                }
+    RETURN_TYPES = ("MODEL", "STRING")
+    RETURN_NAMES = ("model", "cache key")
+
+    FUNCTION = "doit"
+
+    CATEGORY = "InspirePack/Backend"
+
+    def doit(self, model_name, weight_dtype, key_opt, mode='Auto'):
+        if mode == 'Read Only':
+            if key_opt.strip() == '':
+                raise Exception("[LoadDiffusionModelShared] key_opt cannot be omit if mode is 'Read Only'")
+            key = key_opt.strip()
+        elif key_opt.strip() == '':
+            key = f"{model_name}_{weight_dtype}"
+        else:
+            key = key_opt.strip()
+
+        if key not in cache or mode == 'Override Cache':
+            model = self.load_unet(model_name, weight_dtype)[0]
+            update_cache(key, "diffusion", (False, model))
+            print(f"[Inspire Pack] LoadDiffusionModelShared: diffusion model '{model_name}' is cached to '{key}'.")
+        else:
+            _, (_, model) = cache[key]
+            print(f"[Inspire Pack] LoadDiffusionModelShared: Cached diffusion model '{key}' is loaded. (Loading skip)")
+
+        return model, key
+
+    @staticmethod
+    def IS_CHANGED(model_name, weight_dtype, key_opt, mode='Auto'):
+        if mode == 'Read Only':
+            if key_opt.strip() == '':
+                raise Exception("[LoadDiffusionModelShared] key_opt cannot be omit if mode is 'Read Only'")
+            key = key_opt.strip()
+        elif key_opt.strip() == '':
+            key = f"{model_name}_{weight_dtype}"
+        else:
+            key = key_opt.strip()
+
+        if mode == 'Read Only':
+            return None, cache_weak_hash(key)
+        elif mode == 'Override Cache':
+            return model_name, key
+
+        return None, cache_weak_hash(key)
+
+
+class LoadTextEncoderShared:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model_name1": (folder_paths.get_filename_list("text_encoders"), ),
+                              "model_name2": (["None"] + folder_paths.get_filename_list("text_encoders"), ),
+                              "model_name3": (["None"] + folder_paths.get_filename_list("text_encoders"), ),
+                              "type": (["stable_diffusion", "stable_cascade", "sd3", "stable_audio", "mochi", "ltxv", "pixart", "cosmos", "sdxl", "flux", "hunyuan_video"], ),
+                              "key_opt": ("STRING", {"multiline": False, "placeholder": "If empty, use 'model_name' as the key."}),
+                              "mode": (['Auto', 'Override Cache', 'Read Only'],),
+                              },
+                "optional": { "device": (["default", "cpu"], {"advanced": True}), }
+                }
+    RETURN_TYPES = ("CLIP", "STRING")
+    RETURN_NAMES = ("clip", "cache key")
+
+    FUNCTION = "doit"
+
+    CATEGORY = "InspirePack/Backend"
+
+    DESCRIPTION = \
+        ("[Recipes single]\n"
+         "stable_diffusion: clip-l\n"
+         "stable_cascade: clip-g\n"
+         "sd3: t5 / clip-g / clip-l\n"
+         "stable_audio: t5\n"
+         "mochi: t5\n"
+         "cosmos: old t5 xxl\n\n"
+         "[Recipes dual]\n"
+         "sdxl: clip-l, clip-g\n"
+         "sd3: clip-l, clip-g / clip-l, t5 / clip-g, t5\n"
+         "flux: clip-l, t5\n\n"
+         "[Recipes triple]\n"
+         "sd3: clip-l, clip-g, t5")
+
+    def doit(self, model_name1, model_name2, model_name3, type, key_opt, mode='Auto', device="default"):
+        if mode == 'Read Only':
+            if key_opt.strip() == '':
+                raise Exception("[LoadTextEncoderShared] key_opt cannot be omit if mode is 'Read Only'")
+            key = key_opt.strip()
+        elif key_opt.strip() == '':
+            key = model_name1
+            if model_name2 is not None:
+                key += f"_{model_name2}"
+            if model_name3 is not None:
+                key += f"_{model_name3}"
+            key += f"_{type}_{device}"
+        else:
+            key = key_opt.strip()
+
+        if key not in cache or mode == 'Override Cache':
+            if model_name2 != "None" and model_name3 != "None": # triple text encoder
+                if len({model_name1, model_name2, model_name3}) < 3:
+                    logging.error("[LoadTextEncoderShared] The same model has been selected multiple times.")
+                    raise ValueError("The same model has been selected multiple times.")
+
+                if type not in ["sd3"]:
+                    logging.error("[LoadTextEncoderShared] Currently, the triple text encoder is only supported in `sd3`.")
+                    raise ValueError("Currently, the triple text encoder is only supported in `sd3`.")
+
+                res = nodes.NODE_CLASS_MAPPINGS["TripleCLIPLoader"]().load_clip(model_name1, model_name2, model_name3)[0]
+
+            elif model_name2 != "None" or model_name3 != "None": # dual text encoder
+                second_model = model_name2 if model_name2 != "None" else model_name3
+
+                if model_name1 == second_model:
+                    logging.error("[LoadTextEncoderShared] You have selected the same model for both.")
+                    raise ValueError("[LoadTextEncoderShared] You have selected the same model for both.")
+
+                if type not in ["sdxl", "sd3", "flux", "hunyuan_video"]:
+                    logging.error("[LoadTextEncoderShared] Currently, the triple text encoder is only supported in `sdxl, sd3, flux, hunyuan_video`.")
+                    raise ValueError("Currently, the triple text encoder is only supported in `sdxl, sd3, flux, hunyuan_video`.")
+
+                res = nodes.NODE_CLASS_MAPPINGS["DualCLIPLoader"]().load_clip(model_name1, second_model, type=type, device=device)[0]
+
+            else: # single text encoder
+                if type not in ["stable_diffusion", "stable_cascade", "sd3", "stable_audio", "mochi", "ltxv", "pixart", "cosmos"]:
+                    logging.error("[LoadTextEncoderShared] Currently, the single text encoder is only supported in `stable_diffusion, stable_cascade, sd3, stable_audio, mochi, ltxv, pixart, cosmos`.")
+                    raise ValueError("Currently, the single text encoder is only supported in `stable_diffusion, stable_cascade, sd3, stable_audio, mochi, ltxv, pixart, cosmos`.")
+
+                res = nodes.NODE_CLASS_MAPPINGS["CLIPLoader"]().load_clip(model_name1, type=type, device=device)[0]
+
+            update_cache(key, "diffusion", (False, res))
+            print(f"[Inspire Pack] LoadTextEncoderShared: text encoder model set is cached to '{key}'.")
+        else:
+            _, (_, res) = cache[key]
+            print(f"[Inspire Pack] LoadTextEncoderShared: Cached text encoder model set '{key}' is loaded. (Loading skip)")
+
+        return res, key
+
+    @staticmethod
+    def IS_CHANGED(model_name1, model_name2, model_name3, type, key_opt, mode='Auto', device="default"):
+        if mode == 'Read Only':
+            if key_opt.strip() == '':
+                raise Exception("[LoadTextEncoderShared] key_opt cannot be omit if mode is 'Read Only'")
+            key = key_opt.strip()
+        elif key_opt.strip() == '':
+            key = model_name1
+            if model_name2 is not None:
+                key += f"_{model_name2}"
+            if model_name3 is not None:
+                key += f"_{model_name3}"
+            key += f"_{type}_{device}"
+        else:
+            key = key_opt.strip()
+
+        if mode == 'Read Only':
+            return None, cache_weak_hash(key)
+        elif mode == 'Override Cache':
+            return f"{model_name1}_{model_name2}_{model_name3}_{type}_{device}", key
+
+        return None, cache_weak_hash(key)
+
+
 class StableCascade_CheckpointLoader:
     @classmethod
     def INPUT_TYPES(s):
@@ -478,6 +649,74 @@ class StableCascade_CheckpointLoader:
         return b_model, b_vae, c_model, c_vae, clip_vision, clip, key_b, key_c
 
 
+class IsCached:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "key": ("STRING", {"multiline": False}),
+            },
+            "hidden": {
+                "unique_id": "UNIQUE_ID"
+            }
+        }
+
+    RETURN_TYPES = ("BOOLEAN", )
+    FUNCTION = "doit"
+
+    CATEGORY = "InspirePack/Backend"
+
+    @staticmethod
+    def IS_CHANGED(key, unique_id):
+        return common.is_changed(unique_id, key in cache)
+
+    def doit(self, key, unique_id):
+        return (key in cache,)
+
+
+# WIP: not properly working, yet
+class CacheBridge:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": (any_typ,),
+                "mode": ("BOOLEAN", {"default": True, "label_off": "cached", "label_on": "passthrough"}),
+            },
+            "hidden": {
+                "unique_id": "UNIQUE_ID"
+            }
+        }
+
+    RETURN_TYPES = (any_typ, )
+    RETURN_NAMES = ("value",)
+
+    FUNCTION = "doit"
+
+    CATEGORY = "InspirePack/Backend"
+
+    @staticmethod
+    def IS_CHANGED(value, mode, unique_id):
+        if not mode and unique_id in common.changed_cache:
+            return common.not_changed_value(unique_id)
+        else:
+            return common.changed_value(unique_id)
+
+    def doit(self, value, mode, unique_id):
+        if not mode:
+            # cache mode
+            if unique_id not in common.changed_cache:
+                common.changed_cache[unique_id] = value
+                common.changed_count_cache[unique_id] = 0
+
+            return (common.changed_cache[unique_id],)
+        else:
+            common.changed_cache[unique_id] = value
+            common.changed_count_cache[unique_id] = 0
+
+            return (common.changed_cache[unique_id],)
+
+
 NODE_CLASS_MAPPINGS = {
     "CacheBackendData //Inspire": CacheBackendData,
     "CacheBackendDataNumberKey //Inspire": CacheBackendDataNumberKey,
@@ -489,7 +728,11 @@ NODE_CLASS_MAPPINGS = {
     "RemoveBackendDataNumberKey //Inspire": RemoveBackendDataNumberKey,
     "ShowCachedInfo //Inspire": ShowCachedInfo,
     "CheckpointLoaderSimpleShared //Inspire": CheckpointLoaderSimpleShared,
-    "StableCascade_CheckpointLoader //Inspire": StableCascade_CheckpointLoader
+    "LoadDiffusionModelShared //Inspire": LoadDiffusionModelShared,
+    "LoadTextEncoderShared //Inspire": LoadTextEncoderShared,
+    "StableCascade_CheckpointLoader //Inspire": StableCascade_CheckpointLoader,
+    "IsCached //Inspire": IsCached,
+    # "CacheBridge //Inspire": CacheBridge,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
@@ -503,5 +746,9 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "RemoveBackendDataNumberKey //Inspire": "Remove Backend Data [NumberKey] (Inspire)",
     "ShowCachedInfo //Inspire": "Show Cached Info (Inspire)",
     "CheckpointLoaderSimpleShared //Inspire": "Shared Checkpoint Loader (Inspire)",
-    "StableCascade_CheckpointLoader //Inspire": "Stable Cascade Checkpoint Loader (Inspire)"
+    "LoadDiffusionModelShared //Inspire": "Shared Diffusion Model Loader (Inspire)",
+    "LoadTextEncoderShared //Inspire": "Shared Text Encoder Loader (Inspire)",
+    "StableCascade_CheckpointLoader //Inspire": "Stable Cascade Checkpoint Loader (Inspire)",
+    "IsCached //Inspire": "Is Cached (Inspire)",
+    # "CacheBridge //Inspire": "Cache Bridge (Inspire)"
 }

inspire/image_util.py

@@ -18,7 +18,7 @@ class LoadImagesFromDirBatch:
             },
             "optional": {
                 "image_load_cap": ("INT", {"default": 0, "min": 0, "step": 1}),
-                "start_index": ("INT", {"default": 0, "min": -1, "step": 1}),
+                "start_index": ("INT", {"default": 0, "min": -1, "max": 0xffffffffffffffff, "step": 1}),
                 "load_always": ("BOOLEAN", {"default": False, "label_on": "enabled", "label_off": "disabled"}),
             }
         }
@@ -121,7 +121,7 @@ class LoadImagesFromDirList:
             },
             "optional": {
                 "image_load_cap": ("INT", {"default": 0, "min": 0, "step": 1}),
-                "start_index": ("INT", {"default": 0, "min": 0, "step": 1}),
+                "start_index": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "step": 1}),
                 "load_always": ("BOOLEAN", {"default": False, "label_on": "enabled", "label_off": "disabled"}),
             }
         }

inspire/inspire_server.py

@@ -6,6 +6,7 @@ from enum import Enum
 from . import prompt_support
 from aiohttp import web
 from . import backend_support
+from .libs import common
 
 
 max_seed = 2**32 - 1
@@ -271,7 +272,17 @@ def populate_wildcards(json_data):
         for k, v in prompt.items():
             if 'class_type' in v and v['class_type'] == 'WildcardEncode //Inspire':
                 inputs = v['inputs']
-                if inputs['mode'] and isinstance(inputs['populated_text'], str):
+
+                # legacy adapter
+                if isinstance(inputs['mode'], bool):
+                    if inputs['mode']:
+                        new_mode = 'populate'
+                    else:
+                        new_mode = 'fixed'
+
+                    inputs['mode'] = new_mode
+
+                if inputs['mode'] == 'populate' and isinstance(inputs['populated_text'], str):
                     if isinstance(inputs['seed'], list):
                         try:
                             input_node = prompt[inputs['seed'][0]]
@@ -292,14 +303,17 @@ def populate_wildcards(json_data):
                         input_seed = int(inputs['seed'])
 
                     inputs['populated_text'] = wildcard_process(text=inputs['wildcard_text'], seed=input_seed)
-                    inputs['mode'] = False
+                    inputs['mode'] = 'reproduce'
 
                     server.PromptServer.instance.send_sync("inspire-node-feedback", {"node_id": k, "widget_name": "populated_text", "type": "text", "data": inputs['populated_text']})
                     updated_widget_values[k] = inputs['populated_text']
 
+                if inputs['mode'] == 'reproduce':
+                    server.PromptServer.instance.send_sync("inspire-node-feedback", {"node_id": k, "widget_name": "mode", "type": "text", "value": 'populate'})
+
             elif 'class_type' in v and v['class_type'] == 'MakeBasicPipe //Inspire':
                 inputs = v['inputs']
-                if inputs['wildcard_mode'] and (isinstance(inputs['positive_populated_text'], str) or isinstance(inputs['negative_populated_text'], str)):
+                if inputs['wildcard_mode'] == 'populate' and (isinstance(inputs['positive_populated_text'], str) or isinstance(inputs['negative_populated_text'], str)):
                     if isinstance(inputs['seed'], list):
                         try:
                             input_node = prompt[inputs['seed'][0]]
@@ -327,9 +341,12 @@ def populate_wildcards(json_data):
                         inputs['negative_populated_text'] = wildcard_process(text=inputs['negative_wildcard_text'], seed=input_seed)
                         server.PromptServer.instance.send_sync("inspire-node-feedback", {"node_id": k, "widget_name": "negative_populated_text", "type": "text", "data": inputs['negative_populated_text']})
 
-                    inputs['wildcard_mode'] = False
+                    inputs['wildcard_mode'] = 'reproduce'
                     mbp_updated_widget_values[k] = inputs['positive_populated_text'], inputs['negative_populated_text']
 
+                if inputs['wildcard_mode'] == 'reproduce':
+                    server.PromptServer.instance.send_sync("inspire-node-feedback", {"node_id": k, "widget_name": "wildcard_mode", "type": "text", "value": 'populate'})
+
         if 'extra_data' in json_data and 'extra_pnginfo' in json_data['extra_data']:
             extra_pnginfo = json_data['extra_data']['extra_pnginfo']
             if 'workflow' in extra_pnginfo and extra_pnginfo['workflow'] is not None and 'nodes' in extra_pnginfo['workflow']:
@@ -337,11 +354,11 @@ def populate_wildcards(json_data):
                     key = str(node['id'])
                     if key in updated_widget_values:
                         node['widgets_values'][3] = updated_widget_values[key]
-                        node['widgets_values'][4] = False
+                        node['widgets_values'][4] = 'reproduce'
                     if key in mbp_updated_widget_values:
                         node['widgets_values'][7] = mbp_updated_widget_values[key][0]
                         node['widgets_values'][8] = mbp_updated_widget_values[key][1]
-                        node['widgets_values'][5] = False
+                        node['widgets_values'][5] = 'reproduce'
 
 
 def force_reset_useless_params(json_data):
@@ -354,6 +371,21 @@ def force_reset_useless_params(json_data):
     return json_data
 
 
+def clear_unused_node_changed_cache(json_data):
+    prompt = json_data['prompt']
+
+    unused = []
+    for x in common.changed_cache.keys():
+        if x not in prompt:
+            unused.append(x)
+
+    for x in unused:
+        del common.changed_cache[x]
+        del common.changed_count_cache[x]
+
+    return json_data
+
+
 def onprompt(json_data):
     prompt_support.list_counter_map = {}
 
@@ -367,6 +399,7 @@ def onprompt(json_data):
     populate_wildcards(json_data)
 
     force_reset_useless_params(json_data)
+    clear_unused_node_changed_cache(json_data)
 
     return json_data
 

inspire/libs/common.py

@@ -12,3 +12,30 @@ def impact_sampling(*args, **kwargs):
         raise Exception(f"[ERROR] You need to install 'ComfyUI-Impact-Pack'")
 
     return nodes.NODE_CLASS_MAPPINGS['RegionalSampler'].separated_sample(*args, **kwargs)
+
+
+changed_count_cache = {}
+changed_cache = {}
+
+
+def changed_value(uid):
+    v = changed_count_cache.get(uid, 0)
+    changed_count_cache[uid] = v + 1
+    return v + 1
+
+
+def not_changed_value(uid):
+    return changed_count_cache.get(uid, 0)
+
+
+def is_changed(uid, value):
+    if uid not in changed_cache or changed_cache[uid] != value:
+        res = changed_value(uid)
+    else:
+        res = not_changed_value(uid)
+
+    changed_cache[uid] = value
+
+    print(f"keys: {changed_cache.keys()}")
+
+    return res

inspire/prompt_support.py

@@ -60,20 +60,23 @@ class LoadPromptsFromDir:
                     },
                 "optional": {
                     "reload": ("BOOLEAN", { "default": False, "label_on": "if file changed", "label_off": "if value changed"}),
+                    "load_cap": ("INT", {"default": 0, "min": 0, "step": 1, "advanced": True, "tooltip": "The amount of prompts to load at once:\n0: Load all\n1 or higher: Load a specified number"}),
+                    "start_index": ("INT", {"default": 0, "min": -1, "step": 1, "max": 0xffffffffffffffff, "advanced": True, "tooltip": "Starting index for loading prompts:\n-1: The last prompt\n0 or higher: Load from the specified index"}),
                     }
                 }
 
-    RETURN_TYPES = ("ZIPPED_PROMPT",)
-    OUTPUT_IS_LIST = (True,)
+    RETURN_TYPES = ("ZIPPED_PROMPT", "INT", "INT")
+    RETURN_NAMES = ("zipped_prompt", "count", "remaining_count")
+    OUTPUT_IS_LIST = (True, False, False)
 
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Prompt"
 
     @staticmethod
-    def IS_CHANGED(prompt_dir, reload=False):
+    def IS_CHANGED(prompt_dir, reload=False, load_cap=0, start_index=-1):
         if not reload:
-            return prompt_dir
+            return prompt_dir, load_cap, start_index
         else:
             candidates = []
             for d in folder_paths.get_folder_paths('inspire_prompts'):
@@ -99,10 +102,10 @@ class LoadPromptsFromDir:
                             break
                         md5.update(chunk)
 
-            return md5.hexdigest()
+            return md5.hexdigest(), load_cap, start_index
 
     @staticmethod
-    def doit(prompt_dir, reload=False):
+    def doit(prompt_dir, reload=False, load_cap=0, start_index=-1):
         candidates = []
         for d in folder_paths.get_folder_paths('inspire_prompts'):
             candidates.append(os.path.join(d, prompt_dir))
@@ -125,20 +128,29 @@ class LoadPromptsFromDir:
                     prompt_list = re.split(r'\n\s*-+\s*\n', prompt_data)
 
                     for prompt in prompt_list:
-                        pattern = r"positive:(.*?)(?:\n*|$)negative:(.*)"
+                        pattern = r"^(?:(?:positive:(?P<positive>.*?)|negative:(?P<negative>.*?)|name:(?P<name>.*?))\n*)+$"
                         matches = re.search(pattern, prompt, re.DOTALL)
 
                         if matches:
-                            positive_text = matches.group(1).strip()
-                            negative_text = matches.group(2).strip()
-                            result_tuple = (positive_text, negative_text, file_name)
+                            positive_text = matches.group('positive').strip()
+                            negative_text = matches.group('negative').strip()
+                            name_text = matches.group('name').strip() if matches.group('name') else file_name
+                            result_tuple = (positive_text, negative_text, name_text)
                             prompts.append(result_tuple)
                         else:
                             print(f"[WARN] LoadPromptsFromDir: invalid prompt format in '{file_name}'")
             except Exception as e:
                 print(f"[ERROR] LoadPromptsFromDir: an error occurred while processing '{file_name}': {str(e)}\nNOTE: Only files with UTF-8 encoding are supported.")
 
-        return (prompts, )
+        # slicing [start_index ~ start_index + load_cap]
+        total_prompts = len(prompts)
+        prompts = prompts[start_index:]
+        remaining_count = False
+        if load_cap > 0:
+            remaining_count = max(0, len(prompts) - load_cap)
+            prompts = prompts[:load_cap]
+
+        return prompts, total_prompts, remaining_count
 
 
 class LoadPromptsFromFile:
@@ -163,25 +175,28 @@ class LoadPromptsFromFile:
                 "optional": {
                         "text_data_opt": ("STRING", {"defaultInput": True}),
                         "reload": ("BOOLEAN", {"default": False, "label_on": "if file changed", "label_off": "if value changed"}),
+                        "load_cap": ("INT", {"default": 0, "min": 0, "step": 1, "advanced": True, "tooltip": "The amount of prompts to load at once:\n0: Load all\n1 or higher: Load a specified number"}),
+                        "start_index": ("INT", {"default": 0, "min": -1, "max": 0xffffffffffffffff, "step": 1, "advanced": True, "tooltip": "Starting index for loading prompts:\n-1: The last prompt\n0 or higher: Load from the specified index"}),
                         }
                 }
 
-    RETURN_TYPES = ("ZIPPED_PROMPT",)
-    OUTPUT_IS_LIST = (True,)
+    RETURN_TYPES = ("ZIPPED_PROMPT", "INT", "INT")
+    RETURN_NAMES = ("zipped_prompt", "count", "remaining_count")
+    OUTPUT_IS_LIST = (True, False, False)
 
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Prompt"
 
     @staticmethod
-    def IS_CHANGED(prompt_file, text_data_opt=None, reload=False):
+    def IS_CHANGED(prompt_file, text_data_opt=None, reload=False, load_cap=0, start_index=-1):
         md5 = hashlib.md5()
 
         if text_data_opt is not None:
             md5.update(text_data_opt)
-            return md5.hexdigest()
+            return md5.hexdigest(), load_cap, start_index
         elif not reload:
-            return prompt_file
+            return prompt_file, load_cap, start_index
         else:
             matched_path = None
             for x in folder_paths.get_folder_paths('inspire_prompts'):
@@ -201,19 +216,21 @@ class LoadPromptsFromFile:
                         break
                     md5.update(chunk)
 
-            return md5.hexdigest()
+            return md5.hexdigest(), load_cap, start_index
 
     @staticmethod
-    def doit(prompt_file, text_data_opt=None, reload=False):
+    def doit(prompt_file, text_data_opt=None, reload=False, load_cap=0, start_index=-1):
         matched_path = None
         for d in folder_paths.get_folder_paths('inspire_prompts'):
             matched_path = os.path.join(d, prompt_file)
-            if not os.path.exists(matched_path):
-                matched_path = None
-            else:
+            if os.path.exists(matched_path):
                 break
+            else:
+                matched_path = None
 
         if matched_path:
+            print(f"[INFO] LoadPromptsFromFile: file found '{prompt_file}'")
+        else:
             print(f"[WARN] LoadPromptsFromFile: file not found '{prompt_file}'")
 
         prompts = []
@@ -226,22 +243,31 @@ class LoadPromptsFromFile:
 
             prompt_list = re.split(r'\n\s*-+\s*\n', prompt_data)
 
-            pattern = r"positive:(.*?)(?:\n*|$)negative:(.*)"
+            pattern = r"^(?:(?:positive:(?P<positive>.*?)|negative:(?P<negative>.*?)|name:(?P<name>.*?))\n*)+$"
 
             for p in prompt_list:
                 matches = re.search(pattern, p, re.DOTALL)
 
                 if matches:
-                    positive_text = matches.group(1).strip()
-                    negative_text = matches.group(2).strip()
-                    result_tuple = (positive_text, negative_text, prompt_file)
+                    positive_text = matches.group('positive').strip()
+                    negative_text = matches.group('negative').strip()
+                    name_text = matches.group('name').strip() if matches.group('name') else prompt_file
+                    result_tuple = (positive_text, negative_text, name_text)
                     prompts.append(result_tuple)
                 else:
                     print(f"[WARN] LoadPromptsFromFile: invalid prompt format in '{prompt_file}'")
         except Exception as e:
             print(f"[ERROR] LoadPromptsFromFile: an error occurred while processing '{prompt_file}': {str(e)}\nNOTE: Only files with UTF-8 encoding are supported.")
 
-        return (prompts, )
+        # slicing [start_index ~ start_index + load_cap]
+        total_prompts = len(prompts)
+        prompts = prompts[start_index:]
+        remaining_count = 0
+        if load_cap > 0:
+            remaining_count = max(0, len(prompts) - load_cap)
+            prompts = prompts[:load_cap]
+
+        return prompts, total_prompts, remaining_count
 
 
 class LoadSinglePromptFromFile:
@@ -286,6 +312,8 @@ class LoadSinglePromptFromFile:
                 prompt_path = None
 
         if prompt_path:
+            print(f"[INFO] LoadSinglePromptFromFile: file found '{prompt_file}'")
+        else:
             print(f"[WARN] LoadSinglePromptFromFile: file not found '{prompt_file}'")
 
         prompts = []
@@ -302,13 +330,14 @@ class LoadSinglePromptFromFile:
             except Exception:
                 prompt = prompt_list[-1]
 
-            pattern = r"positive:(.*?)(?:\n*|$)negative:(.*)"
+            pattern = r"^(?:(?:positive:(?P<positive>.*?)|negative:(?P<negative>.*?)|name:(?P<name>.*?))\n*)+$"
             matches = re.search(pattern, prompt, re.DOTALL)
 
             if matches:
-                positive_text = matches.group(1).strip()
-                negative_text = matches.group(2).strip()
-                result_tuple = (positive_text, negative_text, prompt_file)
+                positive_text = matches.group('positive').strip()
+                negative_text = matches.group('negative').strip()
+                name_text = matches.group('name').strip() if matches.group('name') else prompt_file
+                result_tuple = (positive_text, negative_text, name_text)
                 prompts.append(result_tuple)
             else:
                 print(f"[WARN] LoadSinglePromptFromFile: invalid prompt format in '{prompt_file}'")
@@ -548,7 +577,13 @@ class WildcardEncodeInspire:
                         "weight_interpretation": (["comfy", "A1111", "compel", "comfy++", "down_weight"], {'default': 'comfy++'}),
                         "wildcard_text": ("STRING", {"multiline": True, "dynamicPrompts": False, 'placeholder': 'Wildcard Prompt (User Input)'}),
                         "populated_text": ("STRING", {"multiline": True, "dynamicPrompts": False, 'placeholder': 'Populated Prompt (Will be generated automatically)'}),
-                        "mode": ("BOOLEAN", {"default": True, "label_on": "Populate", "label_off": "Fixed"}),
+
+                        "mode": (["populate", "fixed", "reproduce"], {"default": "populate", "tooltip":
+                            "populate: Before running the workflow, it overwrites the existing value of 'populated_text' with the prompt processed from 'wildcard_text'. In this mode, 'populated_text' cannot be edited.\n"
+                            "fixed: Ignores wildcard_text and keeps 'populated_text' as is. You can edit 'populated_text' in this mode.\n"
+                            "reproduce: This mode operates as 'fixed' mode only once for reproduction, and then it switches to 'populate' mode."
+                                                                               }),
+
                         "Select to add LoRA": (["Select the LoRA to add to the text"] + folder_paths.get_filename_list("loras"), ),
                         "Select to add Wildcard": (["Select the Wildcard to add to the text"],),
                         "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
@@ -589,7 +624,11 @@ class MakeBasicPipe:
                         "Add selection to": ("BOOLEAN", {"default": True, "label_on": "Positive", "label_off": "Negative"}),
                         "Select to add LoRA": (["Select the LoRA to add to the text"] + folder_paths.get_filename_list("loras"),),
                         "Select to add Wildcard": (["Select the Wildcard to add to the text"],),
-                        "wildcard_mode": ("BOOLEAN", {"default": True, "label_on": "Populate", "label_off": "Fixed"}),
+                        "wildcard_mode": (["populate", "fixed", "reproduce"], {"default": "populate", "tooltip":
+                            "populate: Before running the workflow, it overwrites the existing value of 'populated_text' with the prompt processed from 'wildcard_text'. In this mode, 'populated_text' cannot be edited.\n"
+                            "fixed: Ignores wildcard_text and keeps 'populated_text' as is. You can edit 'populated_text' in this mode.\n"
+                            "reproduce: This mode operates as 'fixed' mode only once for reproduction, and then it switches to 'populate' mode."
+                                                                               }),
 
                         "positive_populated_text": ("STRING", {"multiline": True, "dynamicPrompts": False, 'placeholder': 'Populated Positive Prompt (Will be generated automatically)'}),
                         "negative_populated_text": ("STRING", {"multiline": True, "dynamicPrompts": False, 'placeholder': 'Populated Negative Prompt (Will be generated automatically)'}),
@@ -678,7 +717,7 @@ class SeedExplorer:
                 }
         }
 
-    RETURN_TYPES = ("NOISE",)
+    RETURN_TYPES = ("NOISE_IMAGE",)
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Prompt"
@@ -753,15 +792,15 @@ class CompositeNoise:
     def INPUT_TYPES(s):
         return {
             "required": {
-                "destination": ("NOISE",),
-                "source": ("NOISE",),
+                "destination": ("NOISE_IMAGE",),
+                "source": ("NOISE_IMAGE",),
                 "mode": (["center", "left-top", "right-top", "left-bottom", "right-bottom", "xy"], ),
                 "x": ("INT", {"default": 0, "min": 0, "max": nodes.MAX_RESOLUTION, "step": 8}),
                 "y": ("INT", {"default": 0, "min": 0, "max": nodes.MAX_RESOLUTION, "step": 8}),
             },
         }
 
-    RETURN_TYPES = ("NOISE",)
+    RETURN_TYPES = ("NOISE_IMAGE",)
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Prompt"

inspire/regional_nodes.py

@@ -460,7 +460,7 @@ class RegionalSeedExplorerMask:
             "required": {
                 "mask": ("MASK",),
 
-                "noise": ("NOISE",),
+                "noise": ("NOISE_IMAGE",),
                 "seed_prompt": ("STRING", {"multiline": True, "dynamicPrompts": False, "pysssss.autocomplete": False}),
                 "enable_additional": ("BOOLEAN", {"default": True, "label_on": "true", "label_off": "false"}),
                 "additional_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
@@ -471,7 +471,7 @@ class RegionalSeedExplorerMask:
                 {"variation_method": (["linear", "slerp"],), }
         }
 
-    RETURN_TYPES = ("NOISE",)
+    RETURN_TYPES = ("NOISE_IMAGE",)
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Regional"
@@ -517,7 +517,7 @@ class RegionalSeedExplorerColorMask:
                 "color_mask": ("IMAGE",),
                 "mask_color": ("STRING", {"multiline": False, "default": "#FFFFFF"}),
 
-                "noise": ("NOISE",),
+                "noise": ("NOISE_IMAGE",),
                 "seed_prompt": ("STRING", {"multiline": True, "dynamicPrompts": False, "pysssss.autocomplete": False}),
                 "enable_additional": ("BOOLEAN", {"default": True, "label_on": "true", "label_off": "false"}),
                 "additional_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
@@ -528,7 +528,7 @@ class RegionalSeedExplorerColorMask:
                 {"variation_method": (["linear", "slerp"],), }
         }
 
-    RETURN_TYPES = ("NOISE", "MASK")
+    RETURN_TYPES = ("NOISE_IMAGE", "MASK")
     FUNCTION = "doit"
 
     CATEGORY = "InspirePack/Regional"

js/lora_block_weight.js

@@ -34,19 +34,17 @@ app.registerExtension({
 
 			node._value = "Preset";
 
+            node.widgets[preset_i].callback = (v, canvas, node, pos, e) => {
+                node.widgets[vector_i].value = node._value.split(':')[1];
+                if(node.widgets_values) {
+                    node.widgets_values[vector_i] = node.widgets[preset_i].value;
+                }
+            }
+
 			Object.defineProperty(node.widgets[preset_i], "value", {
 				set: (value) => {
-				        const stackTrace = new Error().stack;
-                        if(stackTrace.includes('inner_value_change')) {
-                            if(value != "Preset") {
-                                node.widgets[vector_i].value = value.split(':')[1];
-	                            if(node.widgets_values) {
-	                                node.widgets_values[vector_i] = node.widgets[preset_i].value;
-                                }
-                            }
-                        }
-
-						node._value = value;
+				        if(value != "Preset")
+						    node._value = value;
 					},
 				get: () => {
                         return node._value;
@@ -77,86 +75,86 @@ app.registerExtension({
 		    let preset_i = 9;
 		    let vector_i = 10;
 			node._value = "Preset";
-			Object.defineProperty(node.widgets[preset_i], "value", {
-				set: (value) => {
-				        const stackTrace = new Error().stack;
-                        if(stackTrace.includes('inner_value_change')) {
-                            if(value != "Preset") {
-                                if(!value.startsWith('@') && node.widgets[vector_i].value != "")
-                                    node.widgets[vector_i].value += "\n";
-                                if(value.startsWith('@')) {
-                                    let spec = value.split(':')[1];
-                                    var n;
-                                    var sub_n = null;
-                                    var block = null;
 
-                                    if(isNaN(spec)) {
-                                        let sub_spec = spec.split(',');
+            node.widgets[preset_i].callback = (v, canvas, node, pos, e) => {
+                let value = node._value;
+                if(!value.startsWith('@') && node.widgets[vector_i].value != "")
+                    node.widgets[vector_i].value += "\n";
+                if(value.startsWith('@')) {
+                    let spec = value.split(':')[1];
+                    var n;
+                    var sub_n = null;
+                    var block = null;
 
-                                        if(sub_spec.length != 3) {
-	                                        node.widgets_values[vector_i] = '!! SPEC ERROR !!';
-	                                        node._value = '';
-	                                        return;
-                                        }
+                    if(isNaN(spec)) {
+                        let sub_spec = spec.split(',');
 
-                                        n = parseInt(sub_spec[0].trim());
-                                        sub_n = parseInt(sub_spec[1].trim());
-                                        block = parseInt(sub_spec[2].trim());
-                                    }
-                                    else {
-                                        n = parseInt(spec.trim());
-                                    }
-
-                                    node.widgets[vector_i].value = "";
-                                    if(sub_n == null) {
-                                        for(let i=1; i<=n; i++) {
-                                            var temp = "";
-                                            for(let j=1; j<=n; j++) {
-                                                if(temp!='')
-                                                    temp += ',';
-                                                if(j==i)
-                                                    temp += 'A';
-                                                else
-                                                    temp += '0';
-                                            }
-
-                                            node.widgets[vector_i].value += `B${i}:${temp}\n`;
-                                        }
-                                    }
-                                    else {
-                                        for(let i=1; i<=sub_n; i++) {
-                                            var temp = "";
-                                            for(let j=1; j<=n; j++) {
-                                                if(temp!='')
-                                                    temp += ',';
-
-                                                if(block!=j)
-                                                    temp += '0';
-                                                else {
-                                                    temp += ' ';
-                                                    for(let k=1; k<=sub_n; k++) {
-                                                        if(k==i)
-                                                            temp += 'A ';
-                                                        else
-                                                            temp += '0 ';
-                                                    }
-                                                }
-                                            }
-
-                                            node.widgets[vector_i].value += `B${block}.SUB${i}:${temp}\n`;
-                                        }
-                                    }
-                                }
-                                else {
-                                    node.widgets[vector_i].value += `${value}/${value.split(':')[0]}`;
-                                }
-	                            if(node.widgets_values) {
-	                                node.widgets_values[vector_i] = node.widgets[preset_i].value;
-                                }
-                            }
+                        if(sub_spec.length != 3) {
+                            node.widgets_values[vector_i] = '!! SPEC ERROR !!';
+                            node._value = '';
+                            return;
                         }
 
-						node._value = value;
+                        n = parseInt(sub_spec[0].trim());
+                        sub_n = parseInt(sub_spec[1].trim());
+                        block = parseInt(sub_spec[2].trim());
+                    }
+                    else {
+                        n = parseInt(spec.trim());
+                    }
+
+                    node.widgets[vector_i].value = "";
+                    if(sub_n == null) {
+                        for(let i=1; i<=n; i++) {
+                            var temp = "";
+                            for(let j=1; j<=n; j++) {
+                                if(temp!='')
+                                    temp += ',';
+                                if(j==i)
+                                    temp += 'A';
+                                else
+                                    temp += '0';
+                            }
+
+                            node.widgets[vector_i].value += `B${i}:${temp}\n`;
+                        }
+                    }
+                    else {
+                        for(let i=1; i<=sub_n; i++) {
+                            var temp = "";
+                            for(let j=1; j<=n; j++) {
+                                if(temp!='')
+                                    temp += ',';
+
+                                if(block!=j)
+                                    temp += '0';
+                                else {
+                                    temp += ' ';
+                                    for(let k=1; k<=sub_n; k++) {
+                                        if(k==i)
+                                            temp += 'A ';
+                                        else
+                                            temp += '0 ';
+                                    }
+                                }
+                            }
+
+                            node.widgets[vector_i].value += `B${block}.SUB${i}:${temp}\n`;
+                        }
+                    }
+                }
+                else {
+                    node.widgets[vector_i].value += `${value}/${value.split(':')[0]}`;
+                }
+                if(node.widgets_values) {
+                    node.widgets_values[vector_i] = node.widgets[preset_i].value;
+                }
+            }
+
+			Object.defineProperty(node.widgets[preset_i], "value", {
+				set: (value) => {
+				        if(value != 'Preset')
+						    node._value = value;
 					},
 				get: () => {
                         return node._value;

js/prompt.js

@@ -42,35 +42,38 @@ app.registerExtension({
 			// lora selector, wildcard selector
 			let combo_id = 5;
 
-			Object.defineProperty(node.widgets[combo_id], "value", {
-				set: (value) => {
-						const stackTrace = new Error().stack;
-						if(stackTrace.includes('inner_value_change')) {
-							if(value != "Select the LoRA to add to the text") {
-								let lora_name = value;
-								if (lora_name.endsWith('.safetensors')) {
-									lora_name = lora_name.slice(0, -12);
-								}
+			// lora
+            node.widgets[combo_id].callback = (value, canvas, node, pos, e) => {
+                let lora_name = node._value;
+                if(lora_name.endsWith('.safetensors')) {
+                    lora_name = lora_name.slice(0, -12);
+                }
 
-								wildcard_text_widget.value += `<lora:${lora_name}>`;
-							}
-						}
-					},
-				get: () => { return "Select the LoRA to add to the text"; }
-			});
+                wildcard_text_widget.value += `<lora:${lora_name}>`;
+            }
+
+            Object.defineProperty(node.widgets[combo_id], "value", {
+                set: (value) => {
+                        if (value !== "Select the LoRA to add to the text")
+                            node._value = value;
+                    },
+
+                get: () => { return "Select the LoRA to add to the text"; }
+            });
+
+            // wildcard
+            node.widgets[combo_id+1].callback = (value, canvas, node, pos, e) => {
+                    if(wildcard_text_widget.value != '')
+                        wildcard_text_widget.value += ', '
+
+                    wildcard_text_widget.value += node._wildcard_value;
+            }
 
 			Object.defineProperty(node.widgets[combo_id+1], "value", {
 				set: (value) => {
-						const stackTrace = new Error().stack;
-						if(stackTrace.includes('inner_value_change')) {
-							if(value != "Select the Wildcard to add to the text") {
-								if(wildcard_text_widget.value != '')
-									wildcard_text_widget.value += ', '
-
-								wildcard_text_widget.value += value;
-							}
-						}
-					},
+                    if (value !== "Select the Wildcard to add to the text")
+                        node._wildcard_value = value;
+                },
 				get: () => { return "Select the Wildcard to add to the text"; }
 			});
 
@@ -92,14 +95,20 @@ app.registerExtension({
 			// mode combo
 			Object.defineProperty(mode_widget, "value", {
 				set: (value) => {
-						node._mode_value = value == true || value == "Populate";
-						populated_text_widget.inputEl.disabled = value == true || value == "Populate";
+						if(value == true)
+							node._mode_value = "populate";
+						else if(value == false)
+							node._mode_value = "fixed";
+						else
+							node._mode_value = value; // combo value
+
+						populated_text_widget.inputEl.disabled = node._mode_value == 'populate';
 					},
 				get: () => {
 						if(node._mode_value != undefined)
 							return node._mode_value;
 						else
-							return true;
+							return 'populate';
 					 }
 			});
 		}
@@ -115,47 +124,46 @@ app.registerExtension({
 			// lora selector, wildcard selector
 			let combo_id = 5;
 
+            node.widgets[combo_id].callback = (value, canvas, node, pos, e) => {
+                let lora_name = node._lora_value;
+                if (lora_name.endsWith('.safetensors')) {
+                    lora_name = lora_name.slice(0, -12);
+                }
+
+                if(direction_widget.value) {
+                    pos_wildcard_text_widget.value += `<lora:${lora_name}>`;
+                }
+                else {
+                    neg_wildcard_text_widget.value += `<lora:${lora_name}>`;
+                }
+            }
 			Object.defineProperty(node.widgets[combo_id], "value", {
 				set: (value) => {
-						const stackTrace = new Error().stack;
-						if(stackTrace.includes('inner_value_change')) {
-							if(value != "Select the LoRA to add to the text") {
-								let lora_name = value;
-								if (lora_name.endsWith('.safetensors')) {
-									lora_name = lora_name.slice(0, -12);
-								}
-
-								if(direction_widget.value) {
-									pos_wildcard_text_widget.value += `<lora:${lora_name}>`;
-								}
-								else {
-									neg_wildcard_text_widget.value += `<lora:${lora_name}>`;
-								}
-							}
-						}
+                        if (value !== "Select the LoRA to add to the text")
+                            node._lora_value = value;
 					},
 				get: () => { return "Select the LoRA to add to the text"; }
 			});
 
+            node.widgets[combo_id+1].callback = (value, canvas, node, pos, e) => {
+                let w = null;
+                if(direction_widget.value) {
+                    w = pos_wildcard_text_widget;
+                }
+                else {
+                    w = neg_wildcard_text_widget;
+                }
+
+                if(w.value != '')
+                    w.value += ', '
+
+                w.value += node._wildcard_value;
+            }
+
 			Object.defineProperty(node.widgets[combo_id+1], "value", {
 				set: (value) => {
-						const stackTrace = new Error().stack;
-						if(stackTrace.includes('inner_value_change')) {
-							if(value != "Select the Wildcard to add to the text") {
-								let w = null;
-								if(direction_widget.value) {
-									w = pos_wildcard_text_widget;
-								}
-								else {
-									w = neg_wildcard_text_widget;
-								}
-
-								if(w.value != '')
-									w.value += ', '
-
-								w.value += value;
-							}
-						}
+                        if (value !== "Select the Wildcard to add to the text")
+                            node._wildcard_value = value;
 					},
 				get: () => { return "Select the Wildcard to add to the text"; }
 			});
@@ -178,15 +186,21 @@ app.registerExtension({
 			// mode combo
 			Object.defineProperty(mode_widget, "value", {
 				set: (value) => {
-						pos_populated_text_widget.inputEl.disabled = node._mode_value;
-						neg_populated_text_widget.inputEl.disabled = node._mode_value;
-						node._mode_value = value;
+						if(value == true)
+							node._mode_value = "populate";
+						else if(value == false)
+							node._mode_value = "fixed";
+						else
+							node._mode_value = value; // combo value
+
+						pos_populated_text_widget.inputEl.disabled = node._mode_value == 'populate';
+						neg_populated_text_widget.inputEl.disabled = node._mode_value == 'populate';
 					},
 				get: () => {
 						if(node._mode_value != undefined)
 							return node._mode_value;
 						else
-							return true;
+							return 'populate';
 					 }
 			});
 		}
@@ -205,24 +219,22 @@ app.registerExtension({
 				}
 			});
 
+            preset_widget.callback = (value, canvas, node, pos, e) => {
+                if(node.widgets[2].value) {
+                    node.widgets[2].value += ', ';
+                }
+
+                const y = node._preset_value.split(':');
+                if(y.length == 2)
+                    node.widgets[2].value += y[1].trim();
+                else
+                    node.widgets[2].value += node._preset_value.trim();
+            }
+
 			Object.defineProperty(preset_widget, "value", {
-				set: (x) => {
-					const stackTrace = new Error().stack;
-					if(stackTrace.includes('inner_value_change')) {
-						if(node.widgets[2].value) {
-							node.widgets[2].value += ', ';
-						}
-
-						const y = x.split(':');
-						if(y.length == 2)
-							node.widgets[2].value += y[1].trim();
-						else
-							node.widgets[2].value += x.trim();
-
-						if(node.widgets_values) {
-							node.widgets_values[2] = node.widgets[2].values;
-						}
-					};
+				set: (value) => {
+                    if (value !== "#PRESET")
+                        node._preset_value = value;
 				},
 				get: () => { return '#PRESET'; }
 			});

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-inspire-pack"
 description = "This extension provides various nodes to support Lora Block Weight, Regional Nodes, Backend Cache, Prompt Utils, List Utils, Noise(Seed) Utils, ... and the Impact Pack."
-version = "1.7"
+version = "1.13"
 license = { file = "LICENSE" }
 dependencies = ["matplotlib", "cachetools"]