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.exampleindex 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 nodeClass 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 itimage = 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()