Add nodes for basic string operations

comfy_extras/nodes_string.py

@@ -0,0 +1,331 @@
+import re
+
+from comfy.comfy_types.node_typing import IO
+
+def normalize_path(path):
+    return path.replace('\\', '/')
+
+class StringConcatenate():
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "string_a": (IO.STRING, {"multiline": True}),
+                "string_b": (IO.STRING, {"multiline": True})
+            },
+            "optional": {
+                "separator": (IO.STRING, {"default": ""})
+            }
+        }
+
+    RETURN_TYPES = (IO.STRING,)
+    FUNCTION = "execute"
+    CATEGORY = "utils/string"
+
+    def execute(self, string_a, string_b, separator="", **kwargs):
+        return string_a + separator + 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": (["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": (["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": (["StartsWith", "EndsWith", "Equal"], {"default": "StartsWith"}),
+                "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 == "StartsWith":
+            return a.startswith(b),
+        elif mode == "EndsWith":
+            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": (["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"
+}

nodes.py

@@ -2259,6 +2259,7 @@ def init_builtin_extra_nodes():
         "nodes_hidream.py",
         "nodes_fresca.py",
         "nodes_preview_any.py",
+        "nodes_string.py",
     ]
 
     api_nodes_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_api_nodes")