from typing import Iterator, List, Tuple, Dict, Any, Union, Optional from _decimal import Context, getcontext from decimal import Decimal from nodes import PreviewImage, SaveImage, NODE_CLASS_MAPPINGS as ALL_NODE_CLASS_MAPPINGS from PIL import Image, ImageDraw, ImageFilter, ImageOps from PIL.PngImagePlugin import PngInfo from ..libs.utils import AlwaysEqualProxy, ByPassTypeTuple, cleanGPUUsedForce, compare_revision from ..libs.cache import cache, update_cache, remove_cache from ..libs.log import log_node_info, log_node_warn from ..libs.math import evaluate_formula import numpy as np import time import os import re import csv import json import torch import comfy.utils import folder_paths from comfy_api.latest import io DEFAULT_FLOW_NUM = 2 MAX_FLOW_NUM = 20 # kept for legacy compatibility but no longer used in node definitions any_type = AlwaysEqualProxy("*") lazy_options = {"lazy": True} def validate_list_args(args: Dict[str, List[Any]]) -> Tuple[bool, None, None]: if len(args) == 1: return True, None, None len_to_match = None matched_arg_name = None for arg_name, arg in args.items(): if arg_name == "self": continue if len(arg) != 1: if len_to_match is None: len_to_match = len(arg) matched_arg_name = arg_name elif len(arg) != len_to_match: return False, arg_name, matched_arg_name return True, None, None def error_if_mismatched_list_args(args: Dict[str, List[Any]]) -> None: is_valid, failed_key1, failed_key2 = validate_list_args(args) if not is_valid: assert failed_key1 is not None assert failed_key2 is not None raise ValueError( f"Mismatched list inputs received. {failed_key1}({len(args[failed_key1])}) !== {failed_key2}({len(args[failed_key2])})" ) def zip_with_fill(*lists: Union[List[Any], None]) -> Iterator[Tuple[Any, ...]]: max_len = max(len(lst) if lst is not None else 0 for lst in lists) for i in range(max_len): yield tuple(None if lst is None else (lst[0] if len(lst) == 1 else lst[i]) for lst in lists) # ---------------------------------------------------------------类型 开始----------------------------------------------------------------------# class String(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy string", category="EasyUse/Logic/Type", inputs=[io.String.Input("value", default="")], outputs=[io.String.Output("string")], ) @classmethod def execute(cls, value): return io.NodeOutput(value) class Int(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy int", category="EasyUse/Logic/Type", inputs=[io.Int.Input("value", default=0, min=-999999, max=999999)], outputs=[io.Int.Output("int")], ) @classmethod def execute(cls, value): return io.NodeOutput(value) class RangeInt(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy rangeInt", category="EasyUse/Logic/Type", is_input_list=True, inputs=[ io.Combo.Input("range_mode", options=["step", "num_steps"], default="step"), io.Int.Input("start", default=0, min=-4096, max=4096, step=1), io.Int.Input("stop", default=1, min=-4096, max=4096, step=1), io.Int.Input("step", default=1, min=-4096, max=4096, step=1), io.Int.Input("num_steps", default=0, min=-4096, max=4096, step=1), io.Combo.Input("end_mode", options=["Inclusive", "Exclusive"], default="Inclusive"), ], outputs=[ io.Int.Output("range", is_output_list=True), io.Int.Output("range_sizes", is_output_list=True), ], ) @classmethod def execute(cls, range_mode, start, stop, step, num_steps, end_mode): input_args = {k: v for k, v in locals().items() if k not in ("self", "cls")} error_if_mismatched_list_args(input_args) ranges = [] range_sizes = [] for rm, e_start, e_stop, e_num_steps, e_step, e_end_mode in zip_with_fill( range_mode, start, stop, num_steps, step, end_mode ): if rm == "step": if e_step == 0: vals = [e_start] else: if e_end_mode == "Inclusive": e_stop += 1 vals = list(range(e_start, e_stop, e_step)) ranges.extend(vals) range_sizes.append(len(vals)) elif rm == "num_steps": direction = 1 if e_stop > e_start else -1 if e_end_mode == "Exclusive": e_stop -= direction vals = (np.rint(np.linspace(e_start, e_stop, e_num_steps)).astype(int).tolist()) ranges.extend(vals) range_sizes.append(len(vals)) return io.NodeOutput(ranges, range_sizes) class Float(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy float", category="EasyUse/Logic/Type", inputs=[io.Float.Input("value", default=0, step=0.01, min=-0xffffffffffffffff, max=0xffffffffffffffff)], outputs=[io.Float.Output("float")], ) @classmethod def execute(cls, value): return io.NodeOutput(round(value, 3)) class RangeFloat(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy rangeFloat", category="EasyUse/Logic/Type", is_input_list=True, inputs=[ io.Combo.Input("range_mode", options=["step", "num_steps"], default="step"), io.Float.Input("start", default=0, min=-4096, max=4096, step=0.1), io.Float.Input("stop", default=1.0, min=-4096, max=4096, step=0.1), io.Float.Input("step", default=1.0, min=-4096, max=4096, step=0.1), io.Int.Input("num_steps", default=1, min=-4096, max=4096, step=1), io.Combo.Input("end_mode", options=["Inclusive", "Exclusive"], default="Inclusive"), ], outputs=[ io.Float.Output("range", is_output_list=True), io.Int.Output("range_sizes", is_output_list=True), ], ) @staticmethod def _decimal_range(range_mode, start, stop, step, num_steps, inclusive): if range_mode == "step": ret_val = start if inclusive: stop = stop + step direction = 1 if step > 0 else -1 while (ret_val - stop) * direction < 0: yield float(ret_val) ret_val += step elif range_mode == "num_steps": if num_steps is None or num_steps <= 0: return if num_steps == 1: yield float(start) return if inclusive: s = (stop - start) / Decimal(num_steps - 1) for i in range(num_steps): yield float(stop if i == num_steps - 1 else (start + s * Decimal(i))) else: s = (stop - start) / Decimal(num_steps) for i in range(num_steps): yield float(start + s * Decimal(i)) @classmethod def execute(cls, range_mode, start, stop, step, num_steps, end_mode): input_args = {k: v for k, v in locals().items() if k not in ("self", "cls")} error_if_mismatched_list_args(input_args) getcontext().prec = 12 start = [round(Decimal(s), 2) for s in start] stop = [round(Decimal(s), 2) for s in stop] step = [round(Decimal(s), 2) for s in step] ranges = [] range_sizes = [] for rm, e_start, e_stop, e_step, e_num_steps, e_end_mode in zip_with_fill( range_mode, start, stop, step, num_steps, end_mode ): vals = list(cls._decimal_range(rm, e_start, e_stop, e_step, e_num_steps, e_end_mode == "Inclusive")) ranges.extend(vals) range_sizes.append(len(vals)) return io.NodeOutput(ranges, range_sizes) class Boolean(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy boolean", category="EasyUse/Logic/Type", inputs=[io.Boolean.Input("value", default=False)], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, value): return io.NodeOutput(value) # ---------------------------------------------------------------开关 开始----------------------------------------------------------------------# class imageSwitch(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy imageSwitch", category="EasyUse/Logic/Switch", inputs=[ io.Image.Input("image_a"), io.Image.Input("image_b"), io.Boolean.Input("boolean", default=False), ], outputs=[io.Image.Output("IMAGE")], ) @classmethod def execute(cls, image_a, image_b, boolean): return io.NodeOutput(image_a if boolean else image_b) class textSwitch(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy textSwitch", category="EasyUse/Logic/Switch", inputs=[ io.Int.Input("input", default=1, min=1, max=2), io.String.Input("text1", force_input=True, optional=True), io.String.Input("text2", force_input=True, optional=True), ], outputs=[io.String.Output("STRING")], ) @classmethod def execute(cls, input, text1=None, text2=None): return io.NodeOutput(text1 if input == 1 else text2) # ---------------------------------------------------------------Index Switch----------------------------------------------------------------------# class ab(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy ab", category="EasyUse/Logic", inputs=[ io.Boolean.Input("A or B", default=True, label_on="A", label_off="B"), io.AnyType.Input("in"), ], outputs=[ io.AnyType.Output("A"), io.AnyType.Output("B"), ], hidden=[io.Hidden.unique_id], ) @classmethod def blocker(cls, value, block=False): from comfy_execution.graph import ExecutionBlocker return ExecutionBlocker(None) if block else value @classmethod def execute(cls, **kwargs): is_a = kwargs["A or B"] a = cls.blocker(kwargs["in"], not is_a) b = cls.blocker(kwargs["in"], is_a) return io.NodeOutput(a, b) class anythingInversedSwitch(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy anythingInversedSwitch", category="EasyUse/Logic", inputs=[ io.Int.Input("index", default=0, min=0, max=9, step=1), io.AnyType.Input("in"), ], outputs=[io.AnyType.Output("out%d" % i) for i in range(MAX_FLOW_NUM)], hidden=[io.Hidden.unique_id], ) @classmethod def execute(cls, index, **kwargs): from comfy_execution.graph import ExecutionBlocker res = [kwargs["in"] if index == i else ExecutionBlocker(None) for i in range(MAX_FLOW_NUM)] return io.NodeOutput(*res) class anythingIndexSwitch(io.ComfyNode): @classmethod def define_schema(cls): inputs = [io.Int.Input("index", default=0, min=0, max=9, step=1)] for i in range(MAX_FLOW_NUM): inputs.append(io.AnyType.Input("value%d" % i, optional=True, lazy=True)) return io.Schema( node_id="easy anythingIndexSwitch", category="EasyUse/Logic/Index Switch", inputs=inputs, outputs=[io.AnyType.Output("value")], ) @classmethod def check_lazy_status(cls, index, **kwargs): key = "value%d" % index if kwargs.get(key, None) is None: return [key] @classmethod def execute(cls, index, **kwargs): return io.NodeOutput(kwargs["value%d" % index]) class imageIndexSwitch(io.ComfyNode): @classmethod def define_schema(cls): inputs = [io.Int.Input("index", default=0, min=0, max=9, step=1)] for i in range(MAX_FLOW_NUM): inputs.append(io.Image.Input("image%d" % i, optional=True, lazy=True)) return io.Schema( node_id="easy imageIndexSwitch", category="EasyUse/Logic/Index Switch", inputs=inputs, outputs=[io.Image.Output("image")], ) @classmethod def check_lazy_status(cls, index, **kwargs): key = "image%d" % index if kwargs.get(key, None) is None: return [key] @classmethod def execute(cls, index, **kwargs): return io.NodeOutput(kwargs["image%d" % index]) class textIndexSwitch(io.ComfyNode): @classmethod def define_schema(cls): inputs = [io.Int.Input("index", default=0, min=0, max=9, step=1)] for i in range(MAX_FLOW_NUM): inputs.append(io.String.Input("text%d" % i, optional=True, lazy=True, force_input=True)) return io.Schema( node_id="easy textIndexSwitch", category="EasyUse/Logic/Index Switch", inputs=inputs, outputs=[io.String.Output("text")], ) @classmethod def check_lazy_status(cls, index, **kwargs): key = "text%d" % index if kwargs.get(key, None) is None: return [key] @classmethod def execute(cls, index, **kwargs): return io.NodeOutput(kwargs["text%d" % index]) class conditioningIndexSwitch(io.ComfyNode): @classmethod def define_schema(cls): inputs = [io.Int.Input("index", default=0, min=0, max=9, step=1)] for i in range(MAX_FLOW_NUM): inputs.append(io.Conditioning.Input("cond%d" % i, optional=True, lazy=True)) return io.Schema( node_id="easy conditioningIndexSwitch", category="EasyUse/Logic/Index Switch", inputs=inputs, outputs=[io.Conditioning.Output("conditioning")], ) @classmethod def check_lazy_status(cls, index, **kwargs): key = "cond%d" % index if kwargs.get(key, None) is None: return [key] @classmethod def execute(cls, index, **kwargs): return io.NodeOutput(kwargs["cond%d" % index]) # ---------------------------------------------------------------Math----------------------------------------------------------------------# class mathIntOperation(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy mathInt", category="EasyUse/Logic/Math", inputs=[ io.Int.Input("a", default=0, min=-0xffffffffffffffff, max=0xffffffffffffffff, step=1), io.Int.Input("b", default=0, min=-0xffffffffffffffff, max=0xffffffffffffffff, step=1), io.Combo.Input("operation", options=["add", "subtract", "multiply", "divide", "modulo", "power"]), ], outputs=[io.Int.Output("INT")], ) @classmethod def execute(cls, a, b, operation): ops = { "add": lambda: a + b, "subtract": lambda: a - b, "multiply": lambda: a * b, "divide": lambda: a // b, "modulo": lambda: a % b, "power": lambda: a ** b, } return io.NodeOutput(ops[operation]()) class mathFloatOperation(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy mathFloat", category="EasyUse/Logic/Math", inputs=[ io.Float.Input("a", default=0, min=-999999999999.0, max=999999999999.0, step=0.01), io.Float.Input("b", default=0, min=-999999999999.0, max=999999999999.0, step=0.01), io.Combo.Input("operation", options=["add", "subtract", "multiply", "divide", "modulo", "power"]), ], outputs=[io.Float.Output("FLOAT")], ) @classmethod def execute(cls, a, b, operation): ops = { "add": lambda: round(a + b, 3), "subtract": lambda: round(a - b, 3), "multiply": lambda: round(a * b, 3), "divide": lambda: round(a / b, 3), "modulo": lambda: round(a % b, 3), "power": lambda: round(a ** b, 3), } return io.NodeOutput(ops[operation]()) class mathStringOperation(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy mathString", category="EasyUse/Logic/Math", inputs=[ io.String.Input("a", multiline=False), io.String.Input("b", multiline=False), io.Combo.Input("operation", options=["a == b", "a != b", "a IN b", "a MATCH REGEX(b)", "a BEGINSWITH b", "a ENDSWITH b"]), io.Boolean.Input("case_sensitive", default=True), ], outputs=[io.Boolean.Output("BOOLEAN")], ) @classmethod def execute(cls, a, b, operation, case_sensitive): if not case_sensitive: a = a.lower() b = b.lower() if operation == "a == b": return io.NodeOutput(a == b) elif operation == "a != b": return io.NodeOutput(a != b) elif operation == "a IN b": return io.NodeOutput(a in b) elif operation == "a MATCH REGEX(b)": try: return io.NodeOutput(re.match(b, a) is not None) except Exception: return io.NodeOutput(False) elif operation == "a BEGINSWITH b": return io.NodeOutput(a.startswith(b)) elif operation == "a ENDSWITH b": return io.NodeOutput(a.endswith(b)) class simpleMath(io.ComfyNode): """简单计算器节点,支持字符串数学公式计算""" @classmethod def define_schema(cls): return io.Schema( node_id="easy simpleMath", category="EasyUse/Logic/Math", inputs=[ io.String.Input("value", default="", placeholder="输入数学公式,如: a + b, pow(a, 2), ceil(a / b), floor(a * b), round(a / b, 2)"), io.AnyType.Input("a", optional=True), io.AnyType.Input("b", optional=True), io.AnyType.Input("c", optional=True), ], outputs=[ io.Int.Output("int"), io.Float.Output("float"), io.Boolean.Output("boolean"), ], ) @classmethod def execute(cls, value, a=0, b=0, c=0): try: result = evaluate_formula(value, a, b, c) if isinstance(result, list): result_int = [int(r) for r in result] return io.NodeOutput(result_int, result, [r != 0 for r in result]) result_int = int(result) return io.NodeOutput(result_int, result, result_int != 0) except Exception as e: log_node_warn(f"计算错误: {str(e)}") return io.NodeOutput(0, 0.0, False) class simpleMathDual(io.ComfyNode): """双公式计算器节点,支持两个独立的数学公式计算""" @classmethod def define_schema(cls): return io.Schema( node_id="easy simpleMathDual", category="EasyUse/Logic/Math", inputs=[ io.String.Input("value1", default="", placeholder="输入数学公式1,如: a + b, pow(a, 2), ceil(a / b)"), io.String.Input("value2", default="", placeholder="输入数学公式2,如: c * d, sqrt(c), floor(d / 2)"), io.AnyType.Input("a", optional=True), io.AnyType.Input("b", optional=True), io.AnyType.Input("c", optional=True), io.AnyType.Input("d", optional=True), ], outputs=[ io.Int.Output("int1"), io.Float.Output("float1"), io.Int.Output("int2"), io.Float.Output("float2"), ], ) @classmethod def execute(cls, value1, value2, a=0, b=0, c=0, d=0): try: result1 = evaluate_formula(value1, a, b, c, d) result1_int = [int(r) for r in result1] if isinstance(result1, list) else int(result1) except Exception as e: log_node_warn(f"公式1计算错误: {str(e)}") result1 = 0.0 result1_int = 0 try: result2 = evaluate_formula(value2, a, b, c, d) result2_int = [int(r) for r in result2] if isinstance(result2, list) else int(result2) except Exception as e: log_node_warn(f"公式2计算错误: {str(e)}") result2 = 0.0 result2_int = 0 return io.NodeOutput(result1_int, result1, result2_int, result2) # ---------------------------------------------------------------Flow----------------------------------------------------------------------# try: from comfy_execution.graph_utils import GraphBuilder, is_link from comfy_execution.graph import ExecutionBlocker except Exception: GraphBuilder = None ExecutionBlocker = None class whileLoopStart: def __init__(self): pass @classmethod def INPUT_TYPES(cls): inputs = { "required": { "condition": ("BOOLEAN", {"default": True}), }, "optional": { }, } for i in range(MAX_FLOW_NUM): inputs["optional"]["initial_value%d" % i] = (any_type,) return inputs RETURN_TYPES = ByPassTypeTuple(tuple(["FLOW_CONTROL"] + [any_type] * MAX_FLOW_NUM)) RETURN_NAMES = ByPassTypeTuple(tuple(["flow"] + ["value%d" % i for i in range(MAX_FLOW_NUM)])) FUNCTION = "while_loop_open" CATEGORY = "EasyUse/Logic/While Loop" def while_loop_open(self, condition, **kwargs): values = [] for i in range(MAX_FLOW_NUM): values.append(kwargs.get("initial_value%d" % i, None) if condition else ExecutionBlocker(None)) return tuple(["stub"] + values) class whileLoopEnd: def __init__(self): pass @classmethod def INPUT_TYPES(cls): inputs = { "required": { "flow": ("FLOW_CONTROL", {"rawLink": True}), "condition": ("BOOLEAN", {}), }, "optional": { }, "hidden": { "dynprompt": "DYNPROMPT", "unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO", } } for i in range(MAX_FLOW_NUM): inputs["optional"]["initial_value%d" % i] = (any_type,) return inputs RETURN_TYPES = ByPassTypeTuple(tuple([any_type] * MAX_FLOW_NUM)) RETURN_NAMES = ByPassTypeTuple(tuple(["value%d" % i for i in range(MAX_FLOW_NUM)])) FUNCTION = "while_loop_close" CATEGORY = "EasyUse/Logic/While Loop" def explore_dependencies(self, node_id, dynprompt, upstream, parent_ids): node_info = dynprompt.get_node(node_id) if "inputs" not in node_info: return for k, v in node_info["inputs"].items(): if is_link(v): parent_id = v[0] display_id = dynprompt.get_display_node_id(parent_id) display_node = dynprompt.get_node(display_id) class_type = display_node["class_type"] if class_type not in ['easy forLoopEnd', 'easy whileLoopEnd']: parent_ids.append(display_id) if parent_id not in upstream: upstream[parent_id] = [] self.explore_dependencies(parent_id, dynprompt, upstream, parent_ids) upstream[parent_id].append(node_id) def explore_output_nodes(self, dynprompt, upstream, output_nodes, parent_ids): for parent_id in upstream: display_id = dynprompt.get_display_node_id(parent_id) for output_id in output_nodes: id = output_nodes[output_id][0] if id in parent_ids and display_id == id and output_id not in upstream[parent_id]: if '.' in parent_id: arr = parent_id.split('.') arr[len(arr)-1] = output_id upstream[parent_id].append('.'.join(arr)) else: upstream[parent_id].append(output_id) def collect_contained(self, node_id, upstream, contained): if node_id not in upstream: return for child_id in upstream[node_id]: if child_id not in contained: contained[child_id] = True self.collect_contained(child_id, upstream, contained) def while_loop_close(self, flow, condition, dynprompt=None, unique_id=None,**kwargs): if not condition: # We're done with the loop values = [] for i in range(MAX_FLOW_NUM): values.append(kwargs.get("initial_value%d" % i, None)) return tuple(values) # We want to loop this_node = dynprompt.get_node(unique_id) upstream = {} # Get the list of all nodes between the open and close nodes parent_ids = [] self.explore_dependencies(unique_id, dynprompt, upstream, parent_ids) parent_ids = list(set(parent_ids)) # Get the list of all output nodes between the open and close nodes prompts = dynprompt.get_original_prompt() output_nodes = {} for id in prompts: node = prompts[id] if "inputs" not in node: continue class_type = node["class_type"] class_def = ALL_NODE_CLASS_MAPPINGS[class_type] if hasattr(class_def, 'OUTPUT_NODE') and class_def.OUTPUT_NODE == True: for k, v in node['inputs'].items(): if is_link(v): output_nodes[id] = v graph = GraphBuilder() self.explore_output_nodes(dynprompt, upstream, output_nodes, parent_ids) contained = {} open_node = flow[0] self.collect_contained(open_node, upstream, contained) contained[unique_id] = True contained[open_node] = True for node_id in contained: original_node = dynprompt.get_node(node_id) node = graph.node(original_node["class_type"], "Recurse" if node_id == unique_id else node_id) node.set_override_display_id(node_id) for node_id in contained: original_node = dynprompt.get_node(node_id) node = graph.lookup_node("Recurse" if node_id == unique_id else node_id) for k, v in original_node["inputs"].items(): if is_link(v) and v[0] in contained: parent = graph.lookup_node(v[0]) node.set_input(k, parent.out(v[1])) else: node.set_input(k, v) new_open = graph.lookup_node(open_node) for i in range(MAX_FLOW_NUM): key = "initial_value%d" % i new_open.set_input(key, kwargs.get(key, None)) my_clone = graph.lookup_node("Recurse") result = map(lambda x: my_clone.out(x), range(MAX_FLOW_NUM)) return { "result": tuple(result), "expand": graph.finalize(), } class forLoopStart: def __init__(self): pass @classmethod def INPUT_TYPES(cls): return { "required": { "total": ("INT", {"default": 1, "min": 1, "max": 100000, "step": 1}), }, "optional": { "initial_value%d" % i: (any_type,) for i in range(1, MAX_FLOW_NUM) }, "hidden": { "initial_value0": (any_type,), "prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO", "unique_id": "UNIQUE_ID" } } RETURN_TYPES = ByPassTypeTuple(tuple(["FLOW_CONTROL", "INT"] + [any_type] * (MAX_FLOW_NUM - 1))) RETURN_NAMES = ByPassTypeTuple(tuple(["flow", "index"] + ["value%d" % i for i in range(1, MAX_FLOW_NUM)])) FUNCTION = "for_loop_start" CATEGORY = "EasyUse/Logic/For Loop" def for_loop_start(self, total, prompt=None, extra_pnginfo=None, unique_id=None, **kwargs): graph = GraphBuilder() i = 0 if "initial_value0" in kwargs: i = kwargs["initial_value0"] initial_values = {("initial_value%d" % num): kwargs.get("initial_value%d" % num, None) for num in range(1, MAX_FLOW_NUM)} while_open = graph.node("easy whileLoopStart", condition=total, initial_value0=i, **initial_values) outputs = [kwargs.get("initial_value%d" % num, None) for num in range(1, MAX_FLOW_NUM)] return { "result": tuple(["stub", i] + outputs), "expand": graph.finalize(), } class forLoopEnd: def __init__(self): pass @classmethod def INPUT_TYPES(cls): return { "required": { "flow": ("FLOW_CONTROL", {"rawLink": True}), }, "optional": { "initial_value%d" % i: (any_type, {"rawLink": True}) for i in range(1, MAX_FLOW_NUM) }, "hidden": { "dynprompt": "DYNPROMPT", "extra_pnginfo": "EXTRA_PNGINFO", "unique_id": "UNIQUE_ID" }, } RETURN_TYPES = ByPassTypeTuple(tuple([any_type] * (MAX_FLOW_NUM - 1))) RETURN_NAMES = ByPassTypeTuple(tuple(["value%d" % i for i in range(1, MAX_FLOW_NUM)])) FUNCTION = "for_loop_end" CATEGORY = "EasyUse/Logic/For Loop" def for_loop_end(self, flow, dynprompt=None, extra_pnginfo=None, unique_id=None, **kwargs): graph = GraphBuilder() while_open = flow[0] total = None # Using dynprompt to get the original node forstart_node = dynprompt.get_node(while_open) if forstart_node['class_type'] == 'easy forLoopStart': inputs = forstart_node['inputs'] total = inputs['total'] elif forstart_node['class_type'] == 'easy loadImagesForLoop': inputs = forstart_node['inputs'] limit = inputs['limit'] start_index = inputs['start_index'] # Filter files by extension directory = inputs['directory'] total = graph.node('easy imagesCountInDirectory', directory=directory, limit=limit, start_index=start_index, extension='*').out(0) sub = graph.node("easy mathInt", operation="add", a=[while_open, 1], b=1) cond = graph.node("easy compare", a=sub.out(0), b=total, comparison='a < b') input_values = {("initial_value%d" % i): kwargs.get("initial_value%d" % i, None) for i in range(1, MAX_FLOW_NUM)} while_close = graph.node("easy whileLoopEnd", flow=flow, condition=cond.out(0), initial_value0=sub.out(0), **input_values) return { "result": tuple([while_close.out(i) for i in range(1, MAX_FLOW_NUM)]), "expand": graph.finalize(), } COMPARE_FUNCTIONS = { "a == b": lambda a, b: a == b, "a != b": lambda a, b: a != b, "a < b": lambda a, b: a < b, "a > b": lambda a, b: a > b, "a <= b": lambda a, b: a <= b, "a >= b": lambda a, b: a >= b, "a > 0": lambda a, b: a > 0, "a <= 0": lambda a, b: a <= 0, "b > 0": lambda a, b: b > 0, "b <= 0": lambda a, b: b <= 0, } class Compare(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy compare", category="EasyUse/Logic/Math", inputs=[ io.AnyType.Input("a", optional=True), io.AnyType.Input("b", optional=True), io.Combo.Input("comparison", options=list(COMPARE_FUNCTIONS.keys()), default="a == b", optional=True), ], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, a=0, b=0, comparison="a == b"): return io.NodeOutput(COMPARE_FUNCTIONS[comparison](a, b)) class IfElse(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy ifElse", category="EasyUse/Logic", inputs=[ io.Boolean.Input("boolean"), io.AnyType.Input("on_true", lazy=True), io.AnyType.Input("on_false", lazy=True), ], outputs=[io.AnyType.Output("*")], ) @classmethod def check_lazy_status(cls, boolean=True, on_true=None, on_false=None): if boolean and on_true is None: return ["on_true"] if not boolean and on_false is None: return ["on_false"] @classmethod def execute(cls, **kwargs): return io.NodeOutput(kwargs["on_true"] if kwargs["boolean"] else kwargs["on_false"]) class Blocker(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy blocker", category="EasyUse/Logic", inputs=[ io.Boolean.Input("continue", default=False), io.AnyType.Input("in",), ], outputs=[io.AnyType.Output("out")], ) @classmethod def execute(cls, **kwargs): from comfy_execution.graph import ExecutionBlocker return io.NodeOutput(kwargs["in"] if kwargs["continue"] else ExecutionBlocker(None)) from comfy.sdxl_clip import SDXLClipModel, SDXLRefinerClipModel, SDXLClipG class isMaskEmpty(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy isMaskEmpty", category="EasyUse/Logic", inputs=[io.Mask.Input("mask")], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, mask): if mask is None or torch.all(mask == 0): return io.NodeOutput(True) return io.NodeOutput(False) class isNone(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy isNone", category="EasyUse/Logic", inputs=[io.AnyType.Input("any")], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, any): result = (isinstance(any, str) and any == "") or \ (isinstance(any, (int, float)) and any == 0) or \ any is None return io.NodeOutput(result) class isSDXL(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy isSDXL", category="EasyUse/Logic", inputs=[ io.Custom(io_type="PIPE_LINE").Input("optional_pipe", optional=True), io.Clip.Input("optional_clip", optional=True), ], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, optional_pipe=None, optional_clip=None): if optional_pipe is None and optional_clip is None: raise Exception("[ERROR] optional_pipe or optional_clip is missing") clip = optional_clip if optional_clip is not None else optional_pipe["clip"] return io.NodeOutput(isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG))) class isFileExist(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy isFileExist", category="EasyUse/Logic", inputs=[ io.String.Input("file_path", default=""), io.String.Input("file_name", default=""), io.String.Input("file_extension", default=""), ], outputs=[io.Boolean.Output("boolean")], ) @classmethod def execute(cls, file_path, file_name, file_extension): if not file_path: raise Exception("file_path is missing") if file_name: file_path = os.path.join(file_path, file_name) if file_extension: file_path = file_path + "." + file_extension return io.NodeOutput(os.path.exists(file_path) and os.path.isfile(file_path)) from nodes import MAX_RESOLUTION from ..config import BASE_RESOLUTIONS class pixels(io.ComfyNode): @classmethod def define_schema(cls): resolution_strings = [ f"{width} x {height} (custom)" if width == "width" and height == "height" else f"{width} x {height}" for width, height in BASE_RESOLUTIONS ] return io.Schema( node_id="easy pixels", category="EasyUse/Logic", inputs=[ io.Combo.Input("resolution", options=resolution_strings), io.Int.Input("width", default=512, min=64, max=MAX_RESOLUTION, step=8), io.Int.Input("height", default=512, min=64, max=MAX_RESOLUTION, step=8), io.Float.Input("scale", default=2.000, min=0.001, max=10, step=0.001), io.Boolean.Input("flip_w/h", default=False), ], outputs=[ io.Int.Output("width_norm"), io.Int.Output("height_norm"), io.AnyType.Output("width"), io.AnyType.Output("height"), io.AnyType.Output("scale_factor"), ], ) @classmethod def execute(cls, resolution, width, height, scale, **kwargs): if resolution not in ["自定义 x 自定义", "width x height (custom)"]: try: _width, _height = map(int, resolution.split(" x ")) width = _width height = _height except ValueError: raise ValueError("Invalid base_resolution format.") width = width * scale height = height * scale width_norm = int(width - width % 8) height_norm = int(height - height % 8) if kwargs.get("flip_w/h", False): width, height = height, width width_norm, height_norm = height_norm, width_norm return io.NodeOutput(width_norm, height_norm, width, height, scale) class xyAny(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy xyAny", category="EasyUse/Logic", is_input_list=True, inputs=[ io.AnyType.Input("X"), io.AnyType.Input("Y"), io.Combo.Input("direction", options=["horizontal", "vertical"], default="horizontal"), ], outputs=[ io.AnyType.Output("X", is_output_list=True), io.AnyType.Output("Y", is_output_list=True), ], ) @classmethod def execute(cls, X, Y, direction): new_x, new_y = [], [] if direction[0] == "horizontal": for y in Y: for x in X: new_x.append(x) new_y.append(y) else: for x in X: for y in Y: new_x.append(x) new_y.append(y) return io.NodeOutput(new_x, new_y) class lengthAnything(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy lengthAnything", category="EasyUse/Logic", is_input_list=True, inputs=[io.AnyType.Input("any")], outputs=[io.Int.Output("length")], hidden=[io.Hidden.prompt, io.Hidden.unique_id], ) @classmethod def execute(cls, any, **kwargs): prompt = cls.hidden.prompt my_unique_id = cls.hidden.unique_id if isinstance(prompt, list): prompt = prompt[0] if isinstance(my_unique_id, list): my_unique_id = my_unique_id[0] my_unique_id = my_unique_id.split(".")[-1] if "." in my_unique_id else my_unique_id id, slot = prompt[my_unique_id]["inputs"]["any"] class_type = prompt[id]["class_type"] node_class = ALL_NODE_CLASS_MAPPINGS[class_type] output_is_list = node_class.OUTPUT_IS_LIST[slot] if hasattr(node_class, "OUTPUT_IS_LIST") else False return io.NodeOutput(len(any) if output_is_list or len(any) > 1 else len(any[0])) class indexAnything(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy indexAnything", category="EasyUse/Logic", is_input_list=True, inputs=[ io.AnyType.Input("any"), io.Int.Input("index", default=0, min=-1000000, max=1000000, step=1), ], outputs=[io.AnyType.Output("out")], hidden=[io.Hidden.prompt, io.Hidden.unique_id], ) @classmethod def execute(cls, any, index, **kwargs): if isinstance(index, list): index = index[0] prompt = cls.hidden.prompt my_unique_id = cls.hidden.unique_id if isinstance(prompt, list): prompt = prompt[0] if isinstance(my_unique_id, list): my_unique_id = my_unique_id[0] my_unique_id = my_unique_id.split(".")[-1] if "." in my_unique_id else my_unique_id id, slot = prompt[my_unique_id]["inputs"]["any"] class_type = prompt[id]["class_type"] node_class = ALL_NODE_CLASS_MAPPINGS[class_type] output_is_list = node_class.OUTPUT_IS_LIST[slot] if hasattr(node_class, "OUTPUT_IS_LIST") else False def normalize_index(idx, length): if idx < 0: idx = length + idx return min(max(0, idx), length - 1) if output_is_list or len(any) > 1: return io.NodeOutput(any[normalize_index(index, len(any))]) elif isinstance(any[0], torch.Tensor): idx = normalize_index(index, any[0].shape[0]) return io.NodeOutput(any[0][idx:idx+1].clone()) else: if hasattr(any[0], "__len__") and len(any[0]) > 0: return io.NodeOutput(any[0][normalize_index(index, len(any[0]))]) return io.NodeOutput(any[0]) class batchAnything(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy batchAnything", category="EasyUse/Logic", inputs=[ io.AnyType.Input("any_1"), io.AnyType.Input("any_2"), ], outputs=[io.AnyType.Output("batch")], ) @classmethod def latentBatch(cls, any_1, any_2): samples_out = any_1.copy() s1 = any_1["samples"] s2 = any_2["samples"] if s1.shape[1:] != s2.shape[1:]: s2 = comfy.utils.common_upscale(s2, s1.shape[3], s1.shape[2], "bilinear", "center") s = torch.cat((s1, s2), dim=0) samples_out["samples"] = s samples_out["batch_index"] = any_1.get("batch_index", list(range(s1.shape[0]))) + \ any_2.get("batch_index", list(range(s2.shape[0]))) return samples_out @classmethod def execute(cls, any_1, any_2): if isinstance(any_1, torch.Tensor) or isinstance(any_2, torch.Tensor): if any_1 is None: return io.NodeOutput(any_2) if any_2 is None: return io.NodeOutput(any_1) if any_1.shape[1:] != any_2.shape[1:]: any_2 = comfy.utils.common_upscale(any_2.movedim(-1, 1), any_1.shape[2], any_1.shape[1], "bilinear", "center").movedim(1, -1) return io.NodeOutput(torch.cat((any_1, any_2), 0)) elif isinstance(any_1, (str, float, int)): if any_2 is None: return io.NodeOutput(any_1) elif isinstance(any_2, tuple): return io.NodeOutput(any_2 + (any_1,)) elif isinstance(any_2, list): return io.NodeOutput(any_2 + [any_1]) return io.NodeOutput([any_1, any_2]) elif isinstance(any_2, (str, float, int)): if any_1 is None: return io.NodeOutput(any_2) elif isinstance(any_1, tuple): return io.NodeOutput(any_1 + (any_2,)) elif isinstance(any_1, list): return io.NodeOutput(any_1 + [any_2]) return io.NodeOutput([any_2, any_1]) elif isinstance(any_1, dict) and "samples" in any_1: if any_2 is None: return io.NodeOutput(any_1) if isinstance(any_2, dict) and "samples" in any_2: return io.NodeOutput(cls.latentBatch(any_1, any_2)) elif isinstance(any_2, dict) and "samples" in any_2: if any_1 is None: return io.NodeOutput(any_2) if isinstance(any_1, dict) and "samples" in any_1: return io.NodeOutput(cls.latentBatch(any_2, any_1)) if any_1 is None: return io.NodeOutput(any_2) if any_2 is None: return io.NodeOutput(any_1) return io.NodeOutput(any_1 + any_2) class convertAnything(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy convertAnything", category="EasyUse/Logic", is_output_node=True, inputs=[ io.AnyType.Input("*"), io.Combo.Input("output_type", options=["string", "int", "float", "boolean"], default="string"), ], outputs=[io.AnyType.Output("output")], ) @classmethod def execute(cls, **kwargs): anything = kwargs["*"] output_type = kwargs["output_type"] converters = {"string": str, "int": int, "float": float, "boolean": bool} return io.NodeOutput(converters[output_type](anything)) class showAnything(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy showAnything", category="EasyUse/Logic", is_input_list=True, is_output_node=True, inputs=[io.AnyType.Input("anything", optional=True)], outputs=[io.AnyType.Output("output")], hidden=[io.Hidden.unique_id, io.Hidden.extra_pnginfo], ) @classmethod def execute(cls, **kwargs): unique_id = cls.hidden.unique_id extra_pnginfo = cls.hidden.extra_pnginfo values = [] if "anything" in kwargs: for val in kwargs["anything"]: if isinstance(val, str): values.append(val) elif isinstance(val, (int, float, bool)): values.append(str(val)) elif isinstance(val, list) and len(val) <= 30: values = val elif val is not None: try: values.append(json.dumps(val, indent=4, ensure_ascii=False)) except Exception: try: values.append(str(val)) except Exception: raise Exception("source exists, but could not be serialized.") if extra_pnginfo and isinstance(extra_pnginfo, dict) and "workflow" in extra_pnginfo: _uid = unique_id[0] if isinstance(unique_id, list) else unique_id node = next((x for x in extra_pnginfo["workflow"]["nodes"] if str(x["id"]) == _uid), None) if node: node["widgets_values"] = [values] result_val = values[0] if (isinstance(values, list) and len(values) == 1) else values return io.NodeOutput(result_val, ui={"text": values}) class showTensorShape(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy showTensorShape", category="EasyUse/Logic", is_output_node=True, inputs=[io.AnyType.Input("tensor")], outputs=[], hidden=[io.Hidden.unique_id, io.Hidden.extra_pnginfo], ) @classmethod def execute(cls, tensor, **kwargs): shapes = [] def tensorShape(t): if isinstance(t, dict): for k in t: tensorShape(t[k]) elif isinstance(t, list): for item in t: tensorShape(item) elif hasattr(t, "shape"): shapes.append(list(t.shape)) tensorShape(tensor) return io.NodeOutput(ui={"text": shapes}) class stringToIntList(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy stringToIntList", category="EasyUse/Logic", inputs=[io.String.Input("string", default="1, 2, 3", multiline=True)], outputs=[io.Int.Output("INT")], ) @classmethod def execute(cls, string): return io.NodeOutput([int(x.strip()) for x in string.split(",")]) class stringToFloatList(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy stringToFloatList", category="EasyUse/Logic", inputs=[io.String.Input("string", default="1, 2, 3", multiline=True)], outputs=[io.Float.Output("FLOAT")], ) @classmethod def execute(cls, string): return io.NodeOutput([float(x.strip()) for x in string.split(",")]) class stringJoinLines(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy stringJoinLines", category="EasyUse/Logic", inputs=[ io.String.Input("string", default="", multiline=True), io.String.Input("delimiter", default=" | "), ], outputs=[io.String.Output("STRING")], ) @classmethod def execute(cls, string, delimiter): lines = [line.strip() for line in string.split("\n") if line.strip()] return io.NodeOutput(delimiter.join(lines)) class outputToList(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy outputToList", category="EasyUse/Logic", inputs=[io.AnyType.Input("tuple")], outputs=[io.AnyType.Output("list", is_output_list=True)], ) @classmethod def execute(cls, tuple): return io.NodeOutput(tuple) class cleanGPUUsed(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy cleanGpuUsed", category="EasyUse/Logic", is_output_node=True, inputs=[io.AnyType.Input("anything")], outputs=[io.AnyType.Output("output")], hidden=[io.Hidden.unique_id, io.Hidden.extra_pnginfo], ) @classmethod def execute(cls, anything, **kwargs): cleanGPUUsedForce() return io.NodeOutput(anything) class clearCacheKey(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy clearCacheKey", category="EasyUse/Logic", is_output_node=True, inputs=[ io.AnyType.Input("anything"), io.String.Input("cache_key", default="*"), ], outputs=[io.AnyType.Output("output")], hidden=[io.Hidden.unique_id, io.Hidden.extra_pnginfo], ) @classmethod def execute(cls, anything, cache_key, **kwargs): remove_cache(cache_key) return io.NodeOutput(anything) class clearCacheAll(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy clearCacheAll", category="EasyUse/Logic", is_output_node=True, inputs=[io.AnyType.Input("anything")], outputs=[io.AnyType.Output("output")], hidden=[io.Hidden.unique_id, io.Hidden.extra_pnginfo], ) @classmethod def execute(cls, anything, **kwargs): remove_cache("*") return io.NodeOutput(anything) class saveText(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy saveText", category="EasyUse/Logic", is_output_node=True, inputs=[ io.String.Input("text", default="", force_input=True), io.String.Input("output_file_path", multiline=False, default=""), io.String.Input("file_name", multiline=False, default=""), io.Combo.Input("file_extension", options=["txt", "csv"]), io.Boolean.Input("overwrite", default=True), io.Image.Input("image", optional=True), ], outputs=[ io.String.Output("text"), io.Image.Output("image"), ], ) @classmethod def save_image(cls, images, filename_prefix="", extension="png", quality=100, prompt=None, extra_pnginfo=None, delimiter="_", filename_number_start="true", number_padding=4, overwrite_mode="prefix_as_filename", output_path="", show_history="true", show_previews="true", embed_workflow="true", lossless_webp=False): for image in images: i = 255. * image.cpu().numpy() img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8)) if extension == "webp": img_exif = img.getexif() workflow_metadata = "" if prompt is not None: img_exif[0x010f] = "Prompt:" + json.dumps(prompt) if extra_pnginfo is not None: for x in extra_pnginfo: workflow_metadata += json.dumps(extra_pnginfo[x]) img_exif[0x010e] = "Workflow:" + workflow_metadata exif_data = img_exif.tobytes() else: metadata = PngInfo() if embed_workflow == "true": if prompt is not None: metadata.add_text("prompt", json.dumps(prompt)) if extra_pnginfo is not None: for x in extra_pnginfo: metadata.add_text(x, json.dumps(extra_pnginfo[x])) exif_data = metadata file = f"{filename_prefix}.{extension}" try: output_file = os.path.abspath(os.path.join(output_path, file)) if extension in ["jpg", "jpeg"]: img.save(output_file, quality=quality, optimize=True) elif extension == "webp": img.save(output_file, quality=quality, lossless=lossless_webp, exif=exif_data) elif extension == "png": img.save(output_file, pnginfo=exif_data, optimize=True) elif extension == "bmp": img.save(output_file) elif extension == "tiff": img.save(output_file, quality=quality, optimize=True) else: img.save(output_file, pnginfo=exif_data, optimize=True) except Exception as e: print(e) @classmethod def execute(cls, text, output_file_path, file_name, file_extension, overwrite, image=None, **kwargs): if isinstance(file_name, list): file_name = file_name[0] if output_file_path == "" or file_name == "": log_node_warn("Save Text", "No file details found. No file output.") return io.NodeOutput(text, None) filepath = os.path.join(output_file_path, file_name) + "." + file_extension if not os.path.exists(output_file_path): os.makedirs(output_file_path) file_mode = "w" if overwrite else "a" log_node_info("Save Text", f"Saving to {filepath}") if file_extension == "csv": with open(filepath, file_mode, newline="", encoding="utf-8") as csv_file: csv_writer = csv.writer(csv_file) for line in [i.strip() for i in text.split("\n")]: csv_writer.writerow([line]) else: with open(filepath, file_mode, newline="", encoding="utf-8") as text_file: for line in text: text_file.write(line) result_image = None if image is not None: imagepath = os.path.join(output_file_path, file_name) index = 1 if not overwrite: while os.path.exists(filepath): imagepath = os.path.join(output_file_path, file_name) + "_" + str(index) index += 1 output_dir = folder_paths.output_directory output_path_val = "" if output_file_path in [None, "", "none", "."] else output_file_path if not os.path.isabs(output_file_path): output_path_val = os.path.join(output_dir, output_path_val) if output_path_val.strip(): if not os.path.isabs(output_path_val): output_path_val = os.path.join(folder_paths.output_directory, output_path_val) if not os.path.exists(output_path_val.strip()): print(f"The path `{output_path_val.strip()}` does not exist! Creating directory.") os.makedirs(output_path_val, exist_ok=True) images_tensor = torch.cat([image], dim=0) cls.save_image(images_tensor, imagepath, "png", 100, None, None, filename_number_start="true", output_path=output_path_val, delimiter="_", number_padding=4, lossless_webp=False) log_node_info("Save Text", f"Saving Image to {imagepath}") result_image = image return io.NodeOutput(text, result_image) class sleep(io.ComfyNode): @classmethod def define_schema(cls): return io.Schema( node_id="easy sleep", category="EasyUse/Logic", inputs=[ io.AnyType.Input("any"), io.Float.Input("delay", default=1.0, min=0.0, max=1000000, step=0.1), ], outputs=[io.AnyType.Output("out")], ) @classmethod def execute(cls, any, delay): time.sleep(delay) return io.NodeOutput(any) NODE_CLASS_MAPPINGS = { "easy string": String, "easy int": Int, "easy rangeInt": RangeInt, "easy float": Float, "easy rangeFloat": RangeFloat, "easy boolean": Boolean, "easy mathString": mathStringOperation, "easy mathInt": mathIntOperation, "easy mathFloat": mathFloatOperation, "easy simpleMath": simpleMath, "easy simpleMathDual": simpleMathDual, "easy compare": Compare, "easy imageSwitch": imageSwitch, "easy textSwitch": textSwitch, "easy imageIndexSwitch": imageIndexSwitch, "easy textIndexSwitch": textIndexSwitch, "easy conditioningIndexSwitch": conditioningIndexSwitch, "easy anythingIndexSwitch": anythingIndexSwitch, "easy ab": ab, "easy anythingInversedSwitch": anythingInversedSwitch, "easy whileLoopStart": whileLoopStart, "easy whileLoopEnd": whileLoopEnd, "easy forLoopStart": forLoopStart, "easy forLoopEnd": forLoopEnd, "easy blocker": Blocker, "easy ifElse": IfElse, "easy isMaskEmpty": isMaskEmpty, "easy isNone": isNone, "easy isSDXL": isSDXL, "easy isFileExist": isFileExist, "easy stringToIntList": stringToIntList, "easy stringToFloatList": stringToFloatList, "easy stringJoinLines": stringJoinLines, "easy outputToList": outputToList, "easy pixels": pixels, "easy xyAny": xyAny, "easy lengthAnything": lengthAnything, "easy indexAnything": indexAnything, "easy batchAnything": batchAnything, "easy convertAnything": convertAnything, "easy showAnything": showAnything, "easy showTensorShape": showTensorShape, "easy clearCacheKey": clearCacheKey, "easy clearCacheAll": clearCacheAll, "easy cleanGpuUsed": cleanGPUUsed, "easy saveText": saveText, "easy sleep": sleep, } NODE_DISPLAY_NAME_MAPPINGS = { "easy string": "String", "easy int": "Int", "easy rangeInt": "Range(Int)", "easy float": "Float", "easy rangeFloat": "Range(Float)", "easy boolean": "Boolean", "easy compare": "Compare", "easy mathString": "Math String", "easy mathInt": "Math Int", "easy mathFloat": "Math Float", "easy simpleMath": "Simple Math", "easy simpleMathDual": "Simple Math Dual", "easy imageSwitch": "Image Switch", "easy textSwitch": "Text Switch", "easy imageIndexSwitch": "Image Index Switch", "easy textIndexSwitch": "Text Index Switch", "easy conditioningIndexSwitch": "Conditioning Index Switch", "easy anythingIndexSwitch": "Any Index Switch", "easy ab": "A or B", "easy anythingInversedSwitch": "Any Inversed Switch", "easy whileLoopStart": "While Loop Start", "easy whileLoopEnd": "While Loop End", "easy forLoopStart": "For Loop Start", "easy forLoopEnd": "For Loop End", "easy ifElse": "If else", "easy blocker": "Blocker", "easy isMaskEmpty": "Is Mask Empty", "easy isNone": "Is None", "easy isSDXL": "Is SDXL", "easy isFileExist": "Is File Exist", "easy stringToIntList": "String to Int List", "easy stringToFloatList": "String to Float List", "easy stringJoinLines": "String Join Lines", "easy outputToList": "Output to List", "easy pixels": "Pixels W/H Norm", "easy xyAny": "XY Any", "easy lengthAnything": "Length Any", "easy indexAnything": "Index Any", "easy batchAnything": "Batch Any", "easy convertAnything": "Convert Any", "easy showAnything": "Show Any", "easy showTensorShape": "Show Tensor Shape", "easy clearCacheKey": "Clear Cache Key", "easy clearCacheAll": "Clear Cache All", "easy cleanGpuUsed": "Clean VRAM Used", "easy saveText": "Save Text", "easy sleep": "Sleep", }