From 22bb1569ba1053e7d6f51574177f4ccc9673c647 Mon Sep 17 00:00:00 2001 From: StableLlama Date: Sun, 11 May 2025 13:35:09 +0200 Subject: [PATCH] Finalize comparison nodes --- src/basic_data_handling/comparison_nodes.py | 131 +++++--------------- 1 file changed, 34 insertions(+), 97 deletions(-) diff --git a/src/basic_data_handling/comparison_nodes.py b/src/basic_data_handling/comparison_nodes.py index 625af26..9b1493b 100644 --- a/src/basic_data_handling/comparison_nodes.py +++ b/src/basic_data_handling/comparison_nodes.py @@ -1,7 +1,8 @@ from typing import Any from inspect import cleandoc +from comfy.comfy_types.node_typing import IO, ComfyNodeABC -class Equal: +class Equal(ComfyNodeABC): """ Checks if two values are equal. @@ -12,26 +13,22 @@ class Equal: def INPUT_TYPES(cls): return { "required": { - "value1": ("*", {}), - "value2": ("*", {}), + "value1": (IO.ANY, {}), + "value2": (IO.ANY, {}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool: - return True - def compare(self, value1: Any, value2: Any) -> tuple[bool]: return (value1 == value2,) -class NotEqual: +class NotEqual(ComfyNodeABC): """ Checks if two values are not equal. @@ -42,12 +39,12 @@ class NotEqual: def INPUT_TYPES(cls): return { "required": { - "value1": ("*", {}), - "value2": ("*", {}), + "value1": (IO.ANY, {}), + "value2": (IO.ANY, {}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") @@ -72,25 +69,17 @@ class GreaterThan: def INPUT_TYPES(cls): return { "required": { - "value1": (["FLOAT", "INT"], {}), - "value2": (["FLOAT", "INT"], {}), + "value1": (IO.NUMBER, {"widgetType": "FLOAT"}), + "value2": (IO.NUMBER, {"widgetType": "FLOAT"}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["value1"] not in ("FLOAT", "INT"): - return "value1 must be a FLOAT or INT type" - if input_types["value2"] not in ("FLOAT", "INT"): - return "value2 must be a FLOAT or INT type" - return True - def compare(self, value1: float, value2: float) -> tuple[bool]: return (value1 > value2,) @@ -106,25 +95,17 @@ class LessThan: def INPUT_TYPES(cls): return { "required": { - "value1": (["FLOAT", "INT"], {}), - "value2": (["FLOAT", "INT"], {}), + "value1": (IO.NUMBER, {"widgetType": "FLOAT"}), + "value2": (IO.NUMBER, {"widgetType": "FLOAT"}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["value1"] not in ("FLOAT", "INT"): - return "value1 must be a FLOAT or INT type" - if input_types["value2"] not in ("FLOAT", "INT"): - return "value2 must be a FLOAT or INT type" - return True - def compare(self, value1: float, value2: float) -> tuple[bool]: return (value1 < value2,) @@ -140,25 +121,17 @@ class GreaterThanOrEqual: def INPUT_TYPES(cls): return { "required": { - "value1": (["FLOAT", "INT"], {}), - "value2": (["FLOAT", "INT"], {}), + "value1": (IO.NUMBER, {"widgetType": "FLOAT"}), + "value2": (IO.NUMBER, {"widgetType": "FLOAT"}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["value1"] not in ("FLOAT", "INT"): - return "value1 must be a FLOAT or INT type" - if input_types["value2"] not in ("FLOAT", "INT"): - return "value2 must be a FLOAT or INT type" - return True - def compare(self, value1: float, value2: float) -> tuple[bool]: return (value1 >= value2,) @@ -174,25 +147,17 @@ class LessThanOrEqual: def INPUT_TYPES(cls): return { "required": { - "value1": (["FLOAT", "INT"], {}), - "value2": (["FLOAT", "INT"], {}), + "value1": (IO.NUMBER, {"widgetType": "FLOAT"}), + "value2": (IO.NUMBER, {"widgetType": "FLOAT"}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["value1"] not in ("FLOAT", "INT"): - return "value1 must be a FLOAT or INT type" - if input_types["value2"] not in ("FLOAT", "INT"): - return "value2 must be a FLOAT or INT type" - return True - def compare(self, value1: float, value2: float) -> tuple[bool]: return (value1 <= value2,) @@ -211,24 +176,16 @@ class StringComparison: "string1": ("STRING", {"default": ""}), "string2": ("STRING", {"default": ""}), "operator": (["==", "!=", ">", "<", ">=", "<="], {"default": "=="}), - "case_sensitive": (["True", "False"], {"default": "True"}), + "case_sensitive": (IO.BOOLEAN, {"default": True}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("result",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["string1"] != "STRING": - return "string1 must be a STRING type" - if input_types["string2"] != "STRING": - return "string2 must be a STRING type" - return True - def compare(self, string1: str, string2: str, operator: str, case_sensitive: str) -> tuple[bool]: if case_sensitive == "False": string1 = string1.lower() @@ -262,32 +219,22 @@ class NumberInRange: def INPUT_TYPES(cls): return { "required": { - "value": (["FLOAT", "INT"], {}), - "min_value": (["FLOAT", "INT"], {"default": 0}), - "max_value": (["FLOAT", "INT"], {"default": 100}), + "value": (IO.NUMBER, {"widgetType": "FLOAT"}), + "min_value": ("FLOAT", {"default": 0}), + "max_value": ("FLOAT", {"default": 100}), }, "optional": { - "include_min": (["True", "False"], {"default": "True"}), - "include_max": (["True", "False"], {"default": "True"}), + "include_min": (IO.BOOLEAN, {"default": "True"}), + "include_max": (IO.BOOLEAN, {"default": "True"}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("in_range",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "check_range" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["value"] not in ("FLOAT", "INT"): - return "value must be a FLOAT or INT type" - if input_types["min_value"] not in ("FLOAT", "INT"): - return "min_value must be a FLOAT or INT type" - if input_types["max_value"] not in ("FLOAT", "INT"): - return "max_value must be a FLOAT or INT type" - return True - def check_range(self, value: float, min_value: float, max_value: float, include_min: str = "True", include_max: str = "True") -> tuple[bool]: min_check = value >= min_value if include_min == "True" else value > min_value @@ -307,20 +254,16 @@ class IsNull: def INPUT_TYPES(cls): return { "required": { - "value": ("*", {}), + "value": (IO.ANY, {}), } } - RETURN_TYPES = ("BOOLEAN",) + RETURN_TYPES = (IO.BOOLEAN,) RETURN_NAMES = ("is_null",) CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "check_null" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool: - return True - def check_null(self, value: Any) -> tuple[bool]: return (value is None,) @@ -336,24 +279,18 @@ class CompareLength: def INPUT_TYPES(cls): return { "required": { - "container": ("*", {}), + "container": (IO.ANY, {}), "operator": (["==", "!=", ">", "<", ">=", "<="], {"default": "=="}), - "length": ("INT", {"default": 0, "min": 0}), + "length": (IO.INT, {"default": 0, "min": 0}), } } - RETURN_TYPES = ("BOOLEAN", "INT") + RETURN_TYPES = (IO.BOOLEAN, IO.INT) RETURN_NAMES = ("result", "actual_length") CATEGORY = "Basic/comparison" DESCRIPTION = cleandoc(__doc__ or "") FUNCTION = "compare_length" - @classmethod - def VALIDATE_INPUTS(cls, input_types: dict[str, str]) -> bool|str: - if input_types["length"] != "INT": - return "length must be an INT type" - return True - def compare_length(self, container: Any, operator: str, length: int) -> tuple[bool, int]: try: actual_length = len(container)