The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
feat: add Math Expression node with simpleeval evaluation (#12687)
Dantee544c65db91d
diff --git a/comfy_extras/nodes_math.py b/comfy_extras/nodes_math.pynew file mode 100644index 000000000..6417bacf1--- /dev/null+++ b/comfy_extras/nodes_math.py@@ -0,0 +1,119 @@+"""Math expression node using simpleeval for safe evaluation.++Provides a ComfyMathExpression node that evaluates math expressions+against dynamically-grown numeric inputs.+"""++from __future__ import annotations++import math+import string++from simpleeval import simple_eval+from typing_extensions import override++from comfy_api.latest import ComfyExtension, io+++MAX_EXPONENT = 4000+++def _variadic_sum(*args):+ """Support both sum(values) and sum(a, b, c)."""+ if len(args) == 1 and hasattr(args[0], "__iter__"):+ return sum(args[0])+ return sum(args)+++def _safe_pow(base, exp):+ """Wrap pow() with an exponent cap to prevent DoS via huge exponents.++ The ** operator is already guarded by simpleeval's safe_power, but+ pow() as a callable bypasses that guard.+ """+ if abs(exp) > MAX_EXPONENT:+ raise ValueError(f"Exponent {exp} exceeds maximum allowed ({MAX_EXPONENT})")+ return pow(base, exp)+++MATH_FUNCTIONS = {+ "sum": _variadic_sum,+ "min": min,+ "max": max,+ "abs": abs,+ "round": round,+ "pow": _safe_pow,+ "sqrt": math.sqrt,+ "ceil": math.ceil,+ "floor": math.floor,+ "log": math.log,+ "log2": math.log2,+ "log10": math.log10,+ "sin": math.sin,+ "cos": math.cos,+ "tan": math.tan,+ "int": int,+ "float": float,+}+++class MathExpressionNode(io.ComfyNode):+ """Evaluates a math expression against dynamically-grown inputs."""++ @classmethod+ def define_schema(cls) -> io.Schema:+ autogrow = io.Autogrow.TemplateNames(+ input=io.MultiType.Input("value", [io.Float, io.Int]),+ names=list(string.ascii_lowercase),+ min=1,+ )+ return io.Schema(+ node_id="ComfyMathExpression",+ display_name="Math Expression",+ category="math",+ search_aliases=[+ "expression", "formula", "calculate", "calculator",+ "eval", "math",+ ],+ inputs=[+ io.String.Input("expression", default="a + b", multiline=True),+ io.Autogrow.Input("values", template=autogrow),+ ],+ outputs=[+ io.Float.Output(display_name="FLOAT"),+ io.Int.Output(display_name="INT"),+ ],+ )++ @classmethod+ def execute(+ cls, expression: str, values: io.Autogrow.Type+ ) -> io.NodeOutput:+ if not expression.strip():+ raise ValueError("Expression cannot be empty.")++ context: dict = dict(values)+ context["values"] = list(values.values())++ result = simple_eval(expression, names=context, functions=MATH_FUNCTIONS)+ # bool check must come first because bool is a subclass of int in Python+ if isinstance(result, bool) or not isinstance(result, (int, float)):+ raise ValueError(+ f"Math Expression '{expression}' must evaluate to a numeric result, "+ f"got {type(result).__name__}: {result!r}"+ )+ if not math.isfinite(result):+ raise ValueError(+ f"Math Expression '{expression}' produced a non-finite result: {result}"+ )+ return io.NodeOutput(float(result), int(result))+++class MathExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[io.ComfyNode]]:+ return [MathExpressionNode]+++async def comfy_entrypoint() -> MathExtension:+ return MathExtension()diff --git a/nodes.py b/nodes.pyindex 5be9b16f9..0ef23b640 100644--- a/nodes.py+++ b/nodes.py@@ -2449,6 +2449,7 @@ async def init_builtin_extra_nodes():"nodes_replacements.py","nodes_nag.py","nodes_sdpose.py",+ "nodes_math.py",]import_failed = []diff --git a/requirements.txt b/requirements.txtindex 9a674fac5..7bf12247c 100644--- a/requirements.txt+++ b/requirements.txt@@ -24,6 +24,7 @@ av>=14.2.0comfy-kitchen>=0.2.7comfy-aimdo>=0.2.7requests+simpleeval>=1.0#non essential dependencies:kornia>=0.7.1diff --git a/tests-unit/comfy_extras_test/nodes_math_test.py b/tests-unit/comfy_extras_test/nodes_math_test.pynew file mode 100644index 000000000..fa4cdcac3--- /dev/null+++ b/tests-unit/comfy_extras_test/nodes_math_test.py@@ -0,0 +1,197 @@+import math++import pytest+from collections import OrderedDict+from unittest.mock import patch, MagicMock++mock_nodes = MagicMock()+mock_nodes.MAX_RESOLUTION = 16384+mock_server = MagicMock()++with patch.dict("sys.modules", {"nodes": mock_nodes, "server": mock_server}):+ from comfy_extras.nodes_math import MathExpressionNode+++class TestMathExpressionExecute:+ @staticmethod+ def _exec(expression: str, **kwargs) -> object:+ values = OrderedDict(kwargs)+ return MathExpressionNode.execute(expression, values)++ def test_addition(self):+ result = self._exec("a + b", a=3, b=4)+ assert result[0] == 7.0+ assert result[1] == 7++ def test_subtraction(self):+ result = self._exec("a - b", a=10, b=3)+ assert result[0] == 7.0+ assert result[1] == 7++ def test_multiplication(self):+ result = self._exec("a * b", a=3, b=5)+ assert result[0] == 15.0+ assert result[1] == 15++ def test_division(self):+ result = self._exec("a / b", a=10, b=4)+ assert result[0] == 2.5+ assert result[1] == 2++ def test_single_input(self):+ result = self._exec("a * 2", a=5)+ assert result[0] == 10.0+ assert result[1] == 10++ def test_three_inputs(self):+ result = self._exec("a + b + c", a=1, b=2, c=3)+ assert result[0] == 6.0+ assert result[1] == 6++ def test_float_inputs(self):+ result = self._exec("a + b", a=1.5, b=2.5)+ assert result[0] == 4.0+ assert result[1] == 4++ def test_mixed_int_float_inputs(self):+ result = self._exec("a * b", a=1024, b=1.5)+ assert result[0] == 1536.0+ assert result[1] == 1536++ def test_mixed_resolution_scale(self):+ result = self._exec("a * b", a=512, b=0.75)+ assert result[0] == 384.0+ assert result[1] == 384++ def test_sum_values_array(self):+ result = self._exec("sum(values)", a=1, b=2, c=3)+ assert result[0] == 6.0++ def test_sum_variadic(self):+ result = self._exec("sum(a, b, c)", a=1, b=2, c=3)+ assert result[0] == 6.0++ def test_min_values(self):+ result = self._exec("min(values)", a=5, b=2, c=8)+ assert result[0] == 2.0++ def test_max_values(self):+ result = self._exec("max(values)", a=5, b=2, c=8)+ assert result[0] == 8.0++ def test_abs_function(self):+ result = self._exec("abs(a)", a=-7)+ assert result[0] == 7.0+ assert result[1] == 7++ def test_sqrt(self):+ result = self._exec("sqrt(a)", a=16)+ assert result[0] == 4.0+ assert result[1] == 4++ def test_ceil(self):+ result = self._exec("ceil(a)", a=2.3)+ assert result[0] == 3.0+ assert result[1] == 3++ def test_floor(self):+ result = self._exec("floor(a)", a=2.7)+ assert result[0] == 2.0+ assert result[1] == 2++ def test_sin(self):+ result = self._exec("sin(a)", a=0)+ assert result[0] == 0.0++ def test_log10(self):+ result = self._exec("log10(a)", a=100)+ assert result[0] == 2.0+ assert result[1] == 2++ def test_float_output_type(self):+ result = self._exec("a + b", a=1, b=2)+ assert isinstance(result[0], float)++ def test_int_output_type(self):+ result = self._exec("a + b", a=1, b=2)+ assert isinstance(result[1], int)++ def test_non_numeric_result_raises(self):+ with pytest.raises(ValueError, match="must evaluate to a numeric result"):+ self._exec("'hello'", a=42)++ def test_undefined_function_raises(self):+ with pytest.raises(Exception, match="not defined"):+ self._exec("str(a)", a=42)++ def test_boolean_result_raises(self):+ with pytest.raises(ValueError, match="got bool"):+ self._exec("a > b", a=5, b=3)++ def test_empty_expression_raises(self):+ with pytest.raises(ValueError, match="Expression cannot be empty"):+ self._exec("", a=1)++ def test_whitespace_only_expression_raises(self):+ with pytest.raises(ValueError, match="Expression cannot be empty"):+ self._exec(" ", a=1)++ # --- Missing function coverage (round, pow, log, log2, cos, tan) ---++ def test_round(self):+ result = self._exec("round(a)", a=2.7)+ assert result[0] == 3.0+ assert result[1] == 3++ def test_round_with_ndigits(self):+ result = self._exec("round(a, 2)", a=3.14159)+ assert result[0] == pytest.approx(3.14)++ def test_pow(self):+ result = self._exec("pow(a, b)", a=2, b=10)+ assert result[0] == 1024.0+ assert result[1] == 1024++ def test_log(self):+ result = self._exec("log(a)", a=math.e)+ assert result[0] == pytest.approx(1.0)++ def test_log2(self):+ result = self._exec("log2(a)", a=8)+ assert result[0] == pytest.approx(3.0)++ def test_cos(self):+ result = self._exec("cos(a)", a=0)+ assert result[0] == 1.0++ def test_tan(self):+ result = self._exec("tan(a)", a=0)+ assert result[0] == 0.0++ # --- int/float converter functions ---++ def test_int_converter(self):+ result = self._exec("int(a / b)", a=7, b=2)+ assert result[1] == 3++ def test_float_converter(self):+ result = self._exec("float(a)", a=5)+ assert result[0] == 5.0++ # --- Error path tests ---++ def test_division_by_zero_raises(self):+ with pytest.raises(ZeroDivisionError):+ self._exec("a / b", a=1, b=0)++ def test_sqrt_negative_raises(self):+ with pytest.raises(ValueError, match="math domain error"):+ self._exec("sqrt(a)", a=-1)++ def test_overflow_inf_raises(self):+ with pytest.raises(ValueError, match="non-finite result"):+ self._exec("a * b", a=1e308, b=10)++ def test_pow_huge_exponent_raises(self):+ with pytest.raises(ValueError, match="Exponent .* exceeds maximum"):+ self._exec("pow(a, b)", a=10, b=10000000)