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.

update example_node to use V3 schema (#9723)

Alexander Piskun1395bce9f707
diff --git a/custom_nodes/example_node.py.example b/custom_nodes/example_node.py.example
index 29ab2aa72..779c35787 100644
--- a/custom_nodes/example_node.py.example
+++ b/custom_nodes/example_node.py.example
@@ -1,96 +1,70 @@
-class Example:
+from typing_extensions import override
+
+from comfy_api.latest import ComfyExtension, io
+
+
+class Example(io.ComfyNode):
"""
- A example node
+ An example node
Class methods
-------------
- INPUT_TYPES (dict):
- Tell the main program input parameters of nodes.
- IS_CHANGED:
+ define_schema (io.Schema):
+ Tell the main program the metadata, input, output parameters of nodes.
+ fingerprint_inputs:
optional method to control when the node is re executed.
+ check_lazy_status:
+ optional method to control list of input names that need to be evaluated.
- Attributes
- ----------
- RETURN_TYPES (`tuple`):
- The type of each element in the output tuple.
- RETURN_NAMES (`tuple`):
- Optional: The name of each output in the output tuple.
- FUNCTION (`str`):
- The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute()
- OUTPUT_NODE ([`bool`]):
- If this node is an output node that outputs a result/image from the graph. The SaveImage node is an example.
- The backend iterates on these output nodes and tries to execute all their parents if their parent graph is properly connected.
- Assumed to be False if not present.
- CATEGORY (`str`):
- The category the node should appear in the UI.
- DEPRECATED (`bool`):
- Indicates whether the node is deprecated. Deprecated nodes are hidden by default in the UI, but remain
- functional in existing workflows that use them.
- EXPERIMENTAL (`bool`):
- Indicates whether the node is experimental. Experimental nodes are marked as such in the UI and may be subject to
- significant changes or removal in future versions. Use with caution in production workflows.
- execute(s) -> tuple || None:
- The entry point method. The name of this method must be the same as the value of property `FUNCTION`.
- For example, if `FUNCTION = "execute"` then this method's name must be `execute`, if `FUNCTION = "foo"` then it must be `foo`.
"""
- def __init__(self):
- pass
@classmethod
- def INPUT_TYPES(s):
+ def define_schema(cls) -> io.Schema:
"""
- Return a dictionary which contains config for all input fields.
- Some types (string): "MODEL", "VAE", "CLIP", "CONDITIONING", "LATENT", "IMAGE", "INT", "STRING", "FLOAT".
- Input types "INT", "STRING" or "FLOAT" are special values for fields on the node.
- The type can be a list for selection.
-
- Returns: `dict`:
- - Key input_fields_group (`string`): Can be either required, hidden or optional. A node class must have property `required`
- - Value input_fields (`dict`): Contains input fields config:
- * Key field_name (`string`): Name of a entry-point method's argument
- * Value field_config (`tuple`):
- + First value is a string indicate the type of field or a list for selection.
- + Second value is a config for type "INT", "STRING" or "FLOAT".
+ Return a schema which contains all information about the node.
+ Some types: "Model", "Vae", "Clip", "Conditioning", "Latent", "Image", "Int", "String", "Float", "Combo".
+ For outputs the "io.Model.Output" should be used, for inputs the "io.Model.Input" can be used.
+ The type can be a "Combo" - this will be a list for selection.
"""
- return {
- "required": {
- "image": ("IMAGE",),
- "int_field": ("INT", {
- "default": 0,
- "min": 0, #Minimum value
- "max": 4096, #Maximum value
- "step": 64, #Slider's step
- "display": "number", # Cosmetic only: display as "number" or "slider"
- "lazy": True # Will only be evaluated if check_lazy_status requires it
- }),
- "float_field": ("FLOAT", {
- "default": 1.0,
- "min": 0.0,
- "max": 10.0,
- "step": 0.01,
- "round": 0.001, #The value representing the precision to round to, will be set to the step value by default. Can be set to False to disable rounding.
- "display": "number",
- "lazy": True
- }),
- "print_to_screen": (["enable", "disable"],),
- "string_field": ("STRING", {
- "multiline": False, #True if you want the field to look like the one on the ClipTextEncode node
- "default": "Hello World!",
- "lazy": True
- }),
- },
- }
-
- RETURN_TYPES = ("IMAGE",)
- #RETURN_NAMES = ("image_output_name",)
-
- FUNCTION = "test"
-
- #OUTPUT_NODE = False
-
- CATEGORY = "Example"
-
- def check_lazy_status(self, image, string_field, int_field, float_field, print_to_screen):
+ return io.Schema(
+ node_id="Example",
+ display_name="Example Node",
+ category="Example",
+ inputs=[
+ io.Image.Input("image"),
+ io.Int.Input(
+ "int_field",
+ min=0,
+ max=4096,
+ step=64, # Slider's step
+ display_mode=io.NumberDisplay.number, # Cosmetic only: display as "number" or "slider"
+ lazy=True, # Will only be evaluated if check_lazy_status requires it
+ ),
+ io.Float.Input(
+ "float_field",
+ default=1.0,
+ min=0.0,
+ max=10.0,
+ step=0.01,
+ round=0.001, #The value representing the precision to round to, will be set to the step value by default. Can be set to False to disable rounding.
+ display_mode=io.NumberDisplay.number,
+ lazy=True,
+ ),
+ io.Combo.Input("print_to_screen", options=["enable", "disable"]),
+ io.String.Input(
+ "string_field",
+ multiline=False, # True if you want the field to look like the one on the ClipTextEncode node
+ default="Hello world!",
+ lazy=True,
+ )
+ ],
+ outputs=[
+ io.Image.Output(),
+ ],
+ )
+
+ @classmethod
+ def check_lazy_status(cls, image, string_field, int_field, float_field, print_to_screen):
"""
Return a list of input names that need to be evaluated.
@@ -107,7 +81,8 @@ class Example:
else:
return []
- def test(self, image, string_field, int_field, float_field, print_to_screen):
+ @classmethod
+ def execute(cls, image, string_field, int_field, float_field, print_to_screen) -> io.NodeOutput:
if print_to_screen == "enable":
print(f"""Your input contains:
string_field aka input text: {string_field}
@@ -116,7 +91,7 @@ class Example:
""")
#do some processing on the image, in this example I just invert it
image = 1.0 - image
- return (image,)
+ return io.NodeOutput(image)
"""
The node will always be re executed if any of the inputs change but
@@ -127,7 +102,7 @@ class Example:
changes between executions the LoadImage node is executed again.
"""
#@classmethod
- #def IS_CHANGED(s, image, string_field, int_field, float_field, print_to_screen):
+ #def fingerprint_inputs(s, image, string_field, int_field, float_field, print_to_screen):
# return ""
# Set the web directory, any .js file in that directory will be loaded by the frontend as a frontend extension
@@ -143,13 +118,13 @@ async def get_hello(request):
return web.json_response("hello")
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
- "Example": Example
-}
+class ExampleExtension(ComfyExtension):
+ @override
+ async def get_node_list(self) -> list[type[io.ComfyNode]]:
+ return [
+ Example,
+ ]
+
-# A dictionary that contains the friendly/humanly readable titles for the nodes
-NODE_DISPLAY_NAME_MAPPINGS = {
- "Example": "Example Node"
-}
+async def comfy_entrypoint() -> ExampleExtension: # ComfyUI calls this to load your extension and its nodes.
+ return ExampleExtension()