nodes/StableLlama-ComfyUI-basic_data_handling
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Finalize comparison nodes

Browse Source
This commit is contained in:
StableLlama
2025-05-11 13:35:09 +02:00
parent 7c2f6a5a51
commit 22bb1569ba
1 changed files with 34 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/basic_data_handling/comparison_nodes.py
+34 -97
View File
@@ -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)