ComfyUI Lazy Evaluation

ComfyUI Lazy Evaluation

Lazy Evaluation delays input evaluation until actually needed, preventing unnecessary computation.

Lazy Input Declaration

class ConditionalSwitch(io.ComfyNode):
    @classmethod
    def define_schema(cls):
        return io.Schema(
            node_id="ConditionalSwitch",
            category="utils/logic",
            inputs=[
                io.Boolean.Input("condition", default=True),
                io.Image.Input("on_true", lazy=True),
                io.Image.Input("on_false", lazy=True),
            ],
            outputs=[io.Image.Output()],
        )

    def check_lazy_status(self, condition, on_true=None, on_false=None):
        """Return list of inputs still needed. Empty = ready for execute()"""
        needed = []
        if condition and on_true is None:
            needed.append("on_true")
        if not condition and on_false is None:
            needed.append("on_false")
        return needed

    @classmethod
    def execute(cls, condition, on_true=None, on_false=None) -> io.NodeOutput:
        return io.NodeOutput(on_true if condition else on_false)

check_lazy_status() Rules

IMPORTANT: Must be instance method (not classmethod)

# CORRECT
def check_lazy_status(self, condition, on_true=None, on_false=None):
    ...

# WRONG
@classmethod
def check_lazy_status(cls, condition, on_true=None, on_false=None):
    ...

Rules:

1. Use self (instance method)
2. Parameter order matches inputs
3. Lazy inputs need =None default
4. Return list of input names still needed

ExecutionBlocker

Completely blocks execution and all downstream nodes.

from comfy_execution.graph import ExecutionBlocker

@classmethod
def execute(cls, enabled, image) -> io.NodeOutput:
    if not enabled:
        return io.NodeOutput(ExecutionBlocker("Skipping execution"))
    return io.NodeOutput(image)

Lazy vs ExecutionBlocker

Feature	Lazy Evaluation	ExecutionBlocker
Purpose	Delay input evaluation	Block execution completely
Downstream	Runs (gets None)	Doesn't run
Where	check_lazy_status()	execute()

Multi-Condition Example

def check_lazy_status(self, mode, input_a=None, input_b=None, input_c=None):
    needed = []
    if mode == "A" and input_a is None:
        needed.append("input_a")
    elif mode == "B" and input_b is None:
        needed.append("input_b")
    elif mode == "C" and input_c is None:
        needed.append("input_c")
    return needed

Common Mistakes

# WRONG: Return string instead of list
return "on_true"

# CORRECT: Return list
return ["on_true"]

# WRONG: Return None
return None

# CORRECT: Return empty list
return []

Best Practices

1. Request minimum inputs needed
2. Ensure check_lazy_status logic matches execute
3. Handle None in execute
4. Document lazy behavior