Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

Add Number Convert node (#13041)

Dantea0a64c679fca
diff --git a/comfy_extras/nodes_number_convert.py b/comfy_extras/nodes_number_convert.py
new file mode 100644
index 000000000..b2822c856
--- /dev/null
+++ b/comfy_extras/nodes_number_convert.py
@@ -0,0 +1,79 @@
+"""Number Convert node for unified numeric type conversion.
+
+Provides a single node that converts INT, FLOAT, STRING, and BOOL
+inputs into FLOAT and INT outputs.
+"""
+
+from __future__ import annotations
+
+import math
+
+from typing_extensions import override
+
+from comfy_api.latest import ComfyExtension, io
+
+
+class NumberConvertNode(io.ComfyNode):
+ """Converts various types to numeric FLOAT and INT outputs."""
+
+ @classmethod
+ def define_schema(cls) -> io.Schema:
+ return io.Schema(
+ node_id="ComfyNumberConvert",
+ display_name="Number Convert",
+ category="math",
+ search_aliases=[
+ "int to float", "float to int", "number convert",
+ "int2float", "float2int", "cast", "parse number",
+ "string to number", "bool to int",
+ ],
+ inputs=[
+ io.MultiType.Input(
+ "value",
+ [io.Int, io.Float, io.String, io.Boolean],
+ display_name="value",
+ ),
+ ],
+ outputs=[
+ io.Float.Output(display_name="FLOAT"),
+ io.Int.Output(display_name="INT"),
+ ],
+ )
+
+ @classmethod
+ def execute(cls, value) -> io.NodeOutput:
+ if isinstance(value, bool):
+ float_val = 1.0 if value else 0.0
+ elif isinstance(value, (int, float)):
+ float_val = float(value)
+ elif isinstance(value, str):
+ text = value.strip()
+ if not text:
+ raise ValueError("Cannot convert empty string to number.")
+ try:
+ float_val = float(text)
+ except ValueError:
+ raise ValueError(
+ f"Cannot convert string to number: {value!r}"
+ ) from None
+ else:
+ raise TypeError(
+ f"Unsupported input type: {type(value).__name__}"
+ )
+
+ if not math.isfinite(float_val):
+ raise ValueError(
+ f"Cannot convert non-finite value to number: {float_val}"
+ )
+
+ return io.NodeOutput(float_val, int(float_val))
+
+
+class NumberConvertExtension(ComfyExtension):
+ @override
+ async def get_node_list(self) -> list[type[io.ComfyNode]]:
+ return [NumberConvertNode]
+
+
+async def comfy_entrypoint() -> NumberConvertExtension:
+ return NumberConvertExtension()
diff --git a/nodes.py b/nodes.py
index 79874d051..37ceac2fc 100644
--- a/nodes.py
+++ b/nodes.py
@@ -2454,6 +2454,7 @@ async def init_builtin_extra_nodes():
"nodes_nag.py",
"nodes_sdpose.py",
"nodes_math.py",
+ "nodes_number_convert.py",
"nodes_painter.py",
"nodes_curve.py",
]
diff --git a/tests-unit/comfy_extras_test/nodes_number_convert_test.py b/tests-unit/comfy_extras_test/nodes_number_convert_test.py
new file mode 100644
index 000000000..0046fa8f4
--- /dev/null
+++ b/tests-unit/comfy_extras_test/nodes_number_convert_test.py
@@ -0,0 +1,123 @@
+import pytest
+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_number_convert import NumberConvertNode
+
+
+class TestNumberConvertExecute:
+ @staticmethod
+ def _exec(value) -> object:
+ return NumberConvertNode.execute(value)
+
+ # --- INT input ---
+
+ def test_int_input(self):
+ result = self._exec(42)
+ assert result[0] == 42.0
+ assert result[1] == 42
+
+ def test_int_zero(self):
+ result = self._exec(0)
+ assert result[0] == 0.0
+ assert result[1] == 0
+
+ def test_int_negative(self):
+ result = self._exec(-7)
+ assert result[0] == -7.0
+ assert result[1] == -7
+
+ # --- FLOAT input ---
+
+ def test_float_input(self):
+ result = self._exec(3.14)
+ assert result[0] == 3.14
+ assert result[1] == 3
+
+ def test_float_truncation_toward_zero(self):
+ result = self._exec(-2.9)
+ assert result[0] == -2.9
+ assert result[1] == -2 # int() truncates toward zero, not floor
+
+ def test_float_output_type(self):
+ result = self._exec(5)
+ assert isinstance(result[0], float)
+
+ def test_int_output_type(self):
+ result = self._exec(5.7)
+ assert isinstance(result[1], int)
+
+ # --- BOOL input ---
+
+ def test_bool_true(self):
+ result = self._exec(True)
+ assert result[0] == 1.0
+ assert result[1] == 1
+
+ def test_bool_false(self):
+ result = self._exec(False)
+ assert result[0] == 0.0
+ assert result[1] == 0
+
+ # --- STRING input ---
+
+ def test_string_integer(self):
+ result = self._exec("42")
+ assert result[0] == 42.0
+ assert result[1] == 42
+
+ def test_string_float(self):
+ result = self._exec("3.14")
+ assert result[0] == 3.14
+ assert result[1] == 3
+
+ def test_string_negative(self):
+ result = self._exec("-5.5")
+ assert result[0] == -5.5
+ assert result[1] == -5
+
+ def test_string_with_whitespace(self):
+ result = self._exec(" 7.0 ")
+ assert result[0] == 7.0
+ assert result[1] == 7
+
+ def test_string_scientific_notation(self):
+ result = self._exec("1e3")
+ assert result[0] == 1000.0
+ assert result[1] == 1000
+
+ # --- STRING error paths ---
+
+ def test_empty_string_raises(self):
+ with pytest.raises(ValueError, match="Cannot convert empty string"):
+ self._exec("")
+
+ def test_whitespace_only_string_raises(self):
+ with pytest.raises(ValueError, match="Cannot convert empty string"):
+ self._exec(" ")
+
+ def test_non_numeric_string_raises(self):
+ with pytest.raises(ValueError, match="Cannot convert string to number"):
+ self._exec("abc")
+
+ def test_string_inf_raises(self):
+ with pytest.raises(ValueError, match="non-finite"):
+ self._exec("inf")
+
+ def test_string_nan_raises(self):
+ with pytest.raises(ValueError, match="non-finite"):
+ self._exec("nan")
+
+ def test_string_negative_inf_raises(self):
+ with pytest.raises(ValueError, match="non-finite"):
+ self._exec("-inf")
+
+ # --- Unsupported type ---
+
+ def test_unsupported_type_raises(self):
+ with pytest.raises(TypeError, match="Unsupported input type"):
+ self._exec([1, 2, 3])