The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
string node (#7952)
Terry Jiab7ed5f57bda0
diff --git a/comfy_extras/nodes_string.py b/comfy_extras/nodes_string.pynew file mode 100644index 000000000..a852326e5--- /dev/null+++ b/comfy_extras/nodes_string.py@@ -0,0 +1,322 @@+import re++from comfy.comfy_types.node_typing import IO++class StringConcatenate():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string_a": (IO.STRING, {"multiline": True}),+ "string_b": (IO.STRING, {"multiline": True})+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string_a, string_b, **kwargs):+ return string_a + string_b,++class StringSubstring():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "start": (IO.INT, {}),+ "end": (IO.INT, {}),+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, start, end, **kwargs):+ return string[start:end],++class StringLength():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True})+ }+ }++ RETURN_TYPES = (IO.INT,)+ RETURN_NAMES = ("length",)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, **kwargs):+ length = len(string)++ return length,++class CaseConverter():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "mode": (IO.COMBO, {"options": ["UPPERCASE", "lowercase", "Capitalize", "Title Case"]})+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, mode, **kwargs):+ if mode == "UPPERCASE":+ result = string.upper()+ elif mode == "lowercase":+ result = string.lower()+ elif mode == "Capitalize":+ result = string.capitalize()+ elif mode == "Title Case":+ result = string.title()+ else:+ result = string++ return result,+++class StringTrim():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "mode": (IO.COMBO, {"options": ["Both", "Left", "Right"]})+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, mode, **kwargs):+ if mode == "Both":+ result = string.strip()+ elif mode == "Left":+ result = string.lstrip()+ elif mode == "Right":+ result = string.rstrip()+ else:+ result = string++ return result,++class StringReplace():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "find": (IO.STRING, {"multiline": True}),+ "replace": (IO.STRING, {"multiline": True})+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, find, replace, **kwargs):+ result = string.replace(find, replace)+ return result,+++class StringContains():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "substring": (IO.STRING, {"multiline": True}),+ "case_sensitive": (IO.BOOLEAN, {"default": True})+ }+ }++ RETURN_TYPES = (IO.BOOLEAN,)+ RETURN_NAMES = ("contains",)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, substring, case_sensitive, **kwargs):+ if case_sensitive:+ contains = substring in string+ else:+ contains = substring.lower() in string.lower()++ return contains,+++class StringCompare():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string_a": (IO.STRING, {"multiline": True}),+ "string_b": (IO.STRING, {"multiline": True}),+ "mode": (IO.COMBO, {"options": ["Starts With", "Ends With", "Equal"]}),+ "case_sensitive": (IO.BOOLEAN, {"default": True})+ }+ }++ RETURN_TYPES = (IO.BOOLEAN,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string_a, string_b, mode, case_sensitive, **kwargs):+ if case_sensitive:+ a = string_a+ b = string_b+ else:+ a = string_a.lower()+ b = string_b.lower()++ if mode == "Equal":+ return a == b,+ elif mode == "Starts With":+ return a.startswith(b),+ elif mode == "Ends With":+ return a.endswith(b),++class RegexMatch():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "regex_pattern": (IO.STRING, {"multiline": True}),+ "case_insensitive": (IO.BOOLEAN, {"default": True}),+ "multiline": (IO.BOOLEAN, {"default": False}),+ "dotall": (IO.BOOLEAN, {"default": False})+ }+ }++ RETURN_TYPES = (IO.BOOLEAN,)+ RETURN_NAMES = ("matches",)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, regex_pattern, case_insensitive, multiline, dotall, **kwargs):+ flags = 0++ if case_insensitive:+ flags |= re.IGNORECASE+ if multiline:+ flags |= re.MULTILINE+ if dotall:+ flags |= re.DOTALL++ try:+ match = re.search(regex_pattern, string, flags)+ result = match is not None++ except re.error:+ result = False++ return result,+++class RegexExtract():+ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "string": (IO.STRING, {"multiline": True}),+ "regex_pattern": (IO.STRING, {"multiline": True}),+ "mode": (IO.COMBO, {"options": ["First Match", "All Matches", "First Group", "All Groups"]}),+ "case_insensitive": (IO.BOOLEAN, {"default": True}),+ "multiline": (IO.BOOLEAN, {"default": False}),+ "dotall": (IO.BOOLEAN, {"default": False}),+ "group_index": (IO.INT, {"default": 1, "min": 0, "max": 100})+ }+ }++ RETURN_TYPES = (IO.STRING,)+ FUNCTION = "execute"+ CATEGORY = "utils/string"++ def execute(self, string, regex_pattern, mode, case_insensitive, multiline, dotall, group_index, **kwargs):+ join_delimiter = "\n"++ flags = 0+ if case_insensitive:+ flags |= re.IGNORECASE+ if multiline:+ flags |= re.MULTILINE+ if dotall:+ flags |= re.DOTALL++ try:+ if mode == "First Match":+ match = re.search(regex_pattern, string, flags)+ if match:+ result = match.group(0)+ else:+ result = ""++ elif mode == "All Matches":+ matches = re.findall(regex_pattern, string, flags)+ if matches:+ if isinstance(matches[0], tuple):+ result = join_delimiter.join([m[0] for m in matches])+ else:+ result = join_delimiter.join(matches)+ else:+ result = ""++ elif mode == "First Group":+ match = re.search(regex_pattern, string, flags)+ if match and len(match.groups()) >= group_index:+ result = match.group(group_index)+ else:+ result = ""++ elif mode == "All Groups":+ matches = re.finditer(regex_pattern, string, flags)+ results = []+ for match in matches:+ if match.groups() and len(match.groups()) >= group_index:+ results.append(match.group(group_index))+ result = join_delimiter.join(results)+ else:+ result = ""++ except re.error:+ result = ""++ return result,++NODE_CLASS_MAPPINGS = {+ "StringConcatenate": StringConcatenate,+ "StringSubstring": StringSubstring,+ "StringLength": StringLength,+ "CaseConverter": CaseConverter,+ "StringTrim": StringTrim,+ "StringReplace": StringReplace,+ "StringContains": StringContains,+ "StringCompare": StringCompare,+ "RegexMatch": RegexMatch,+ "RegexExtract": RegexExtract+}++NODE_DISPLAY_NAME_MAPPINGS = {+ "StringConcatenate": "Concatenate",+ "StringSubstring": "Substring",+ "StringLength": "Length",+ "CaseConverter": "Case Converter",+ "StringTrim": "Trim",+ "StringReplace": "Replace",+ "StringContains": "Contains",+ "StringCompare": "Compare",+ "RegexMatch": "Regex Match",+ "RegexExtract": "Regex Extract"+}diff --git a/nodes.py b/nodes.pyindex a1ddf2dd6..a26a138fa 100644--- a/nodes.py+++ b/nodes.py@@ -2263,6 +2263,7 @@ def init_builtin_extra_nodes():"nodes_fresca.py","nodes_preview_any.py","nodes_ace.py",+ "nodes_string.py",]import_failed = []