From 632a99ee3f0c73744693d3fffe03ef7a852831ca Mon Sep 17 00:00:00 2001 From: jessesep Date: Fri, 5 Dec 2025 00:35:55 +0100 Subject: [PATCH] Simplify to universal Set/Get Variable nodes - Main nodes: Set Variable, Get Variable, List Variables - Works with ALL data types (Image, Mask, Latent, Model, etc.) - Type-specific nodes moved to deprecated category - Updated documentation --- README.md | 94 ++-- __init__.py | 686 +++++++++++---------------- __pycache__/__init__.cpython-310.pyc | Bin 0 -> 11234 bytes 3 files changed, 306 insertions(+), 474 deletions(-) create mode 100644 __pycache__/__init__.cpython-310.pyc diff --git a/README.md b/README.md index f04ed4f..77c7217 100644 --- a/README.md +++ b/README.md @@ -1,90 +1,62 @@ # ComfyUI Simple Variables -A custom node pack for ComfyUI that provides **Set/Get variable nodes** for storing and retrieving data by name across your workflow. - -## Features - -- Store any ComfyUI data type with a custom variable name -- Retrieve stored variables anywhere in your workflow -- Reduces wire clutter by allowing "wireless" data transfer -- Passthrough design - Set nodes output the same data they receive - -## Supported Variable Types - -| Type | Set Node | Get Node | Category | -|------|----------|----------|----------| -| Image | Set Image Variable | Get Image Variable | `variables/image` | -| Mask | Set Mask Variable | Get Mask Variable | `variables/mask` | -| Latent | Set Latent Variable | Get Latent Variable | `variables/latent` | -| Conditioning | Set Conditioning Variable | Get Conditioning Variable | `variables/conditioning` | -| Model | Set Model Variable | Get Model Variable | `variables/model` | -| CLIP | Set CLIP Variable | Get CLIP Variable | `variables/clip` | -| VAE | Set VAE Variable | Get VAE Variable | `variables/vae` | -| String | Set String Variable | Get String Variable | `variables/primitive` | -| Int | Set Int Variable | Get Int Variable | `variables/primitive` | -| Float | Set Float Variable | Get Float Variable | `variables/primitive` | -| Any | Set Any Variable | Get Any Variable | `variables` | - -### Utility Nodes - -- **List All Variables** - Shows all currently stored variables and their types +A lightweight custom node pack for ComfyUI that provides **Set/Get variable nodes** for storing and retrieving any data by name across your workflow. ## Installation -1. Clone this repository into your ComfyUI `custom_nodes` folder: - ```bash - cd ComfyUI/custom_nodes - git clone SimpleImageVariables - ``` +```bash +cd ComfyUI/custom_nodes +git clone https://github.com/jessesep/ComfyUI-SimpleVariables.git +``` -2. Restart ComfyUI +Restart ComfyUI and search for **"variable"** in the node menu. -3. Search for "variable" in the node menu +## Nodes + +| Node | Description | Category | +|------|-------------|----------| +| **Set Variable** | Store any data with a custom name | `variables` | +| **Get Variable** | Retrieve stored data by name | `variables` | +| **List Variables** | Show all stored variables | `variables` | ## Usage ### Basic Example ``` -[Load Image] → [Set Image Variable] (name: "reference") - ↓ - (passes image through to next node) +[Load Image] → [Set Variable] (name: "reference") + ↓ + (passes through) ... elsewhere in workflow ... -[Get Image Variable] (name: "reference") → [Use Image Node] +[Get Variable] (name: "reference") → [Any Node] ``` ### How It Works -1. **Set nodes** store the input data in memory with your chosen variable name -2. **Set nodes** also pass the data through, so you can continue your workflow normally -3. **Get nodes** retrieve the stored data by variable name -4. Variables persist for the duration of the ComfyUI session +1. **Set Variable** stores any input data with your chosen variable name +2. Data passes through, so you can continue your workflow normally +3. **Get Variable** retrieves stored data anywhere by name +4. Works with ALL ComfyUI data types: Image, Mask, Latent, Model, CLIP, VAE, Conditioning, String, Int, Float, and custom types ### Tips -- Use descriptive variable names like `"upscaled_image"` or `"final_mask"` -- The **Set Any Variable** node accepts any data type (useful for custom node outputs) -- Use **List All Variables** to debug and see what's currently stored -- Variables are cleared when ComfyUI restarts +- Use descriptive names like `"upscaled_image"` or `"final_mask"` +- **List Variables** helps debug what's currently stored +- Variables persist for the ComfyUI session (cleared on restart) +- If a variable doesn't exist, you'll see available variable names in the error -## Node Details +## Why Use This? -### Set Nodes -- **Inputs**: - - `data` - The data to store (type depends on node) - - `variable_name` - String name for the variable -- **Outputs**: Same data that was input (passthrough) +- **Reduce wire clutter** - "Wireless" data transfer across your workflow +- **Reuse outputs** - Store once, use multiple times +- **Simplify complex workflows** - No more spaghetti connections +- **Universal** - One node handles all data types -### Get Nodes -- **Inputs**: - - `variable_name` - String name of the variable to retrieve -- **Outputs**: The stored data +## Deprecated Nodes -### Error Handling - -If you try to Get a variable that hasn't been Set, you'll receive an error message listing all available variable names. +Type-specific nodes (Set Image Variable, Set Mask Variable, etc.) are available under `variables/deprecated` for backward compatibility, but **Set/Get Variable handles all types** so they're no longer needed. ## License @@ -92,4 +64,4 @@ MIT License - Free to use and modify. ## Credits -Created with assistance from Claude (Anthropic) for ComfyUI workflow optimization. +Created by jessesep with assistance from Claude (Anthropic). diff --git a/__init__.py b/__init__.py index 8cf04a4..db9555e 100644 --- a/__init__.py +++ b/__init__.py @@ -1,364 +1,14 @@ """ -Simple Variables - Set and Get nodes for storing/retrieving data by name -Supports: Image, Mask, Latent, Conditioning, Model, CLIP, VAE, String, Int, Float, Any +ComfyUI Simple Variables - Set and Get nodes for storing/retrieving any data by name """ # Global storage for variables _variable_storage = {} -# ============== IMAGE ============== -class SetImageVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "image": ("IMAGE",), - "variable_name": ("STRING", {"default": "my_image"}), - } - } - RETURN_TYPES = ("IMAGE",) - RETURN_NAMES = ("image",) - FUNCTION = "set_var" - CATEGORY = "variables/image" - - def set_var(self, image, variable_name): - _variable_storage[variable_name] = image - return (image,) - - -class GetImageVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_image"})}} - RETURN_TYPES = ("IMAGE",) - RETURN_NAMES = ("image",) - FUNCTION = "get_var" - CATEGORY = "variables/image" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== MASK ============== -class SetMaskVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "mask": ("MASK",), - "variable_name": ("STRING", {"default": "my_mask"}), - } - } - RETURN_TYPES = ("MASK",) - RETURN_NAMES = ("mask",) - FUNCTION = "set_var" - CATEGORY = "variables/mask" - - def set_var(self, mask, variable_name): - _variable_storage[variable_name] = mask - return (mask,) - - -class GetMaskVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_mask"})}} - RETURN_TYPES = ("MASK",) - RETURN_NAMES = ("mask",) - FUNCTION = "get_var" - CATEGORY = "variables/mask" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== LATENT ============== -class SetLatentVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "latent": ("LATENT",), - "variable_name": ("STRING", {"default": "my_latent"}), - } - } - RETURN_TYPES = ("LATENT",) - RETURN_NAMES = ("latent",) - FUNCTION = "set_var" - CATEGORY = "variables/latent" - - def set_var(self, latent, variable_name): - _variable_storage[variable_name] = latent - return (latent,) - - -class GetLatentVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_latent"})}} - RETURN_TYPES = ("LATENT",) - RETURN_NAMES = ("latent",) - FUNCTION = "get_var" - CATEGORY = "variables/latent" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== CONDITIONING ============== -class SetConditioningVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "conditioning": ("CONDITIONING",), - "variable_name": ("STRING", {"default": "my_cond"}), - } - } - RETURN_TYPES = ("CONDITIONING",) - RETURN_NAMES = ("conditioning",) - FUNCTION = "set_var" - CATEGORY = "variables/conditioning" - - def set_var(self, conditioning, variable_name): - _variable_storage[variable_name] = conditioning - return (conditioning,) - - -class GetConditioningVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_cond"})}} - RETURN_TYPES = ("CONDITIONING",) - RETURN_NAMES = ("conditioning",) - FUNCTION = "get_var" - CATEGORY = "variables/conditioning" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== MODEL ============== -class SetModelVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "model": ("MODEL",), - "variable_name": ("STRING", {"default": "my_model"}), - } - } - RETURN_TYPES = ("MODEL",) - RETURN_NAMES = ("model",) - FUNCTION = "set_var" - CATEGORY = "variables/model" - - def set_var(self, model, variable_name): - _variable_storage[variable_name] = model - return (model,) - - -class GetModelVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_model"})}} - RETURN_TYPES = ("MODEL",) - RETURN_NAMES = ("model",) - FUNCTION = "get_var" - CATEGORY = "variables/model" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== CLIP ============== -class SetClipVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "clip": ("CLIP",), - "variable_name": ("STRING", {"default": "my_clip"}), - } - } - RETURN_TYPES = ("CLIP",) - RETURN_NAMES = ("clip",) - FUNCTION = "set_var" - CATEGORY = "variables/clip" - - def set_var(self, clip, variable_name): - _variable_storage[variable_name] = clip - return (clip,) - - -class GetClipVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_clip"})}} - RETURN_TYPES = ("CLIP",) - RETURN_NAMES = ("clip",) - FUNCTION = "get_var" - CATEGORY = "variables/clip" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== VAE ============== -class SetVaeVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "vae": ("VAE",), - "variable_name": ("STRING", {"default": "my_vae"}), - } - } - RETURN_TYPES = ("VAE",) - RETURN_NAMES = ("vae",) - FUNCTION = "set_var" - CATEGORY = "variables/vae" - - def set_var(self, vae, variable_name): - _variable_storage[variable_name] = vae - return (vae,) - - -class GetVaeVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_vae"})}} - RETURN_TYPES = ("VAE",) - RETURN_NAMES = ("vae",) - FUNCTION = "get_var" - CATEGORY = "variables/vae" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== STRING ============== -class SetStringVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "string": ("STRING", {"forceInput": True}), - "variable_name": ("STRING", {"default": "my_string"}), - } - } - RETURN_TYPES = ("STRING",) - RETURN_NAMES = ("string",) - FUNCTION = "set_var" - CATEGORY = "variables/primitive" - - def set_var(self, string, variable_name): - _variable_storage[variable_name] = string - return (string,) - - -class GetStringVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_string"})}} - RETURN_TYPES = ("STRING",) - RETURN_NAMES = ("string",) - FUNCTION = "get_var" - CATEGORY = "variables/primitive" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== INT ============== -class SetIntVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "value": ("INT", {"forceInput": True}), - "variable_name": ("STRING", {"default": "my_int"}), - } - } - RETURN_TYPES = ("INT",) - RETURN_NAMES = ("value",) - FUNCTION = "set_var" - CATEGORY = "variables/primitive" - - def set_var(self, value, variable_name): - _variable_storage[variable_name] = value - return (value,) - - -class GetIntVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_int"})}} - RETURN_TYPES = ("INT",) - RETURN_NAMES = ("value",) - FUNCTION = "get_var" - CATEGORY = "variables/primitive" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== FLOAT ============== -class SetFloatVariable: - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "value": ("FLOAT", {"forceInput": True}), - "variable_name": ("STRING", {"default": "my_float"}), - } - } - RETURN_TYPES = ("FLOAT",) - RETURN_NAMES = ("value",) - FUNCTION = "set_var" - CATEGORY = "variables/primitive" - - def set_var(self, value, variable_name): - _variable_storage[variable_name] = value - return (value,) - - -class GetFloatVariable: - @classmethod - def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_float"})}} - RETURN_TYPES = ("FLOAT",) - RETURN_NAMES = ("value",) - FUNCTION = "get_var" - CATEGORY = "variables/primitive" - - def get_var(self, variable_name): - if variable_name in _variable_storage: - return (_variable_storage[variable_name],) - raise ValueError(f"Variable '{variable_name}' not found") - - -# ============== ANY (Universal) ============== -class SetAnyVariable: +# ============== MAIN NODES ============== +class SetVariable: + """Store any data with a custom variable name""" @classmethod def INPUT_TYPES(cls): return { @@ -366,25 +16,30 @@ class SetAnyVariable: "variable_name": ("STRING", {"default": "my_var"}), }, "optional": { - "any": ("*",), + "value": ("*",), } } RETURN_TYPES = ("*",) - RETURN_NAMES = ("any",) + RETURN_NAMES = ("value",) FUNCTION = "set_var" CATEGORY = "variables" - def set_var(self, variable_name, any=None): - _variable_storage[variable_name] = any - return (any,) + def set_var(self, variable_name, value=None): + _variable_storage[variable_name] = value + return (value,) -class GetAnyVariable: +class GetVariable: + """Retrieve data by variable name""" @classmethod def INPUT_TYPES(cls): - return {"required": {"variable_name": ("STRING", {"default": "my_var"})}} + return { + "required": { + "variable_name": ("STRING", {"default": "my_var"}), + } + } RETURN_TYPES = ("*",) - RETURN_NAMES = ("any",) + RETURN_NAMES = ("value",) FUNCTION = "get_var" CATEGORY = "variables" @@ -394,8 +49,8 @@ class GetAnyVariable: raise ValueError(f"Variable '{variable_name}' not found. Available: {list(_variable_storage.keys())}") -# ============== LIST VARIABLES ============== class ListVariables: + """Show all stored variables""" @classmethod def INPUT_TYPES(cls): return {"required": {}} @@ -409,78 +64,283 @@ class ListVariables: return (var_list if var_list else "(no variables set)",) +# ============== DEPRECATED TYPE-SPECIFIC NODES ============== +# These still work but Set/Get Variable handles all types + +class SetImageVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"image": ("IMAGE",), "variable_name": ("STRING", {"default": "my_image"})}} + RETURN_TYPES = ("IMAGE",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, image, variable_name): + _variable_storage[variable_name] = image + return (image,) + +class GetImageVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_image"})}} + RETURN_TYPES = ("IMAGE",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetMaskVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"mask": ("MASK",), "variable_name": ("STRING", {"default": "my_mask"})}} + RETURN_TYPES = ("MASK",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, mask, variable_name): + _variable_storage[variable_name] = mask + return (mask,) + +class GetMaskVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_mask"})}} + RETURN_TYPES = ("MASK",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetLatentVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"latent": ("LATENT",), "variable_name": ("STRING", {"default": "my_latent"})}} + RETURN_TYPES = ("LATENT",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, latent, variable_name): + _variable_storage[variable_name] = latent + return (latent,) + +class GetLatentVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_latent"})}} + RETURN_TYPES = ("LATENT",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetConditioningVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"conditioning": ("CONDITIONING",), "variable_name": ("STRING", {"default": "my_cond"})}} + RETURN_TYPES = ("CONDITIONING",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, conditioning, variable_name): + _variable_storage[variable_name] = conditioning + return (conditioning,) + +class GetConditioningVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_cond"})}} + RETURN_TYPES = ("CONDITIONING",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetModelVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"model": ("MODEL",), "variable_name": ("STRING", {"default": "my_model"})}} + RETURN_TYPES = ("MODEL",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, model, variable_name): + _variable_storage[variable_name] = model + return (model,) + +class GetModelVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_model"})}} + RETURN_TYPES = ("MODEL",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetClipVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"clip": ("CLIP",), "variable_name": ("STRING", {"default": "my_clip"})}} + RETURN_TYPES = ("CLIP",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, clip, variable_name): + _variable_storage[variable_name] = clip + return (clip,) + +class GetClipVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_clip"})}} + RETURN_TYPES = ("CLIP",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetVaeVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"vae": ("VAE",), "variable_name": ("STRING", {"default": "my_vae"})}} + RETURN_TYPES = ("VAE",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, vae, variable_name): + _variable_storage[variable_name] = vae + return (vae,) + +class GetVaeVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_vae"})}} + RETURN_TYPES = ("VAE",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetStringVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"string": ("STRING", {"forceInput": True}), "variable_name": ("STRING", {"default": "my_string"})}} + RETURN_TYPES = ("STRING",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, string, variable_name): + _variable_storage[variable_name] = string + return (string,) + +class GetStringVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_string"})}} + RETURN_TYPES = ("STRING",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetIntVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"value": ("INT", {"forceInput": True}), "variable_name": ("STRING", {"default": "my_int"})}} + RETURN_TYPES = ("INT",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, value, variable_name): + _variable_storage[variable_name] = value + return (value,) + +class GetIntVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_int"})}} + RETURN_TYPES = ("INT",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + +class SetFloatVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"value": ("FLOAT", {"forceInput": True}), "variable_name": ("STRING", {"default": "my_float"})}} + RETURN_TYPES = ("FLOAT",) + FUNCTION = "set_var" + CATEGORY = "variables/deprecated" + def set_var(self, value, variable_name): + _variable_storage[variable_name] = value + return (value,) + +class GetFloatVariable: + @classmethod + def INPUT_TYPES(cls): + return {"required": {"variable_name": ("STRING", {"default": "my_float"})}} + RETURN_TYPES = ("FLOAT",) + FUNCTION = "get_var" + CATEGORY = "variables/deprecated" + def get_var(self, variable_name): + if variable_name in _variable_storage: return (_variable_storage[variable_name],) + raise ValueError(f"Variable '{variable_name}' not found") + + +# ============== NODE MAPPINGS ============== NODE_CLASS_MAPPINGS = { - # Image + # Main nodes + "SetVariable": SetVariable, + "GetVariable": GetVariable, + "ListVariables": ListVariables, + # Deprecated type-specific nodes "SetImageVariable": SetImageVariable, "GetImageVariable": GetImageVariable, - # Mask "SetMaskVariable": SetMaskVariable, "GetMaskVariable": GetMaskVariable, - # Latent "SetLatentVariable": SetLatentVariable, "GetLatentVariable": GetLatentVariable, - # Conditioning "SetConditioningVariable": SetConditioningVariable, "GetConditioningVariable": GetConditioningVariable, - # Model "SetModelVariable": SetModelVariable, "GetModelVariable": GetModelVariable, - # CLIP "SetClipVariable": SetClipVariable, "GetClipVariable": GetClipVariable, - # VAE "SetVaeVariable": SetVaeVariable, "GetVaeVariable": GetVaeVariable, - # String "SetStringVariable": SetStringVariable, "GetStringVariable": GetStringVariable, - # Int "SetIntVariable": SetIntVariable, "GetIntVariable": GetIntVariable, - # Float "SetFloatVariable": SetFloatVariable, "GetFloatVariable": GetFloatVariable, - # Any - "SetAnyVariable": SetAnyVariable, - "GetAnyVariable": GetAnyVariable, - # Utility - "ListVariables": ListVariables, } NODE_DISPLAY_NAME_MAPPINGS = { - # Image - "SetImageVariable": "Set Image Variable", - "GetImageVariable": "Get Image Variable", - # Mask - "SetMaskVariable": "Set Mask Variable", - "GetMaskVariable": "Get Mask Variable", - # Latent - "SetLatentVariable": "Set Latent Variable", - "GetLatentVariable": "Get Latent Variable", - # Conditioning - "SetConditioningVariable": "Set Conditioning Variable", - "GetConditioningVariable": "Get Conditioning Variable", - # Model - "SetModelVariable": "Set Model Variable", - "GetModelVariable": "Get Model Variable", - # CLIP - "SetClipVariable": "Set CLIP Variable", - "GetClipVariable": "Get CLIP Variable", - # VAE - "SetVaeVariable": "Set VAE Variable", - "GetVaeVariable": "Get VAE Variable", - # String - "SetStringVariable": "Set String Variable", - "GetStringVariable": "Get String Variable", - # Int - "SetIntVariable": "Set Int Variable", - "GetIntVariable": "Get Int Variable", - # Float - "SetFloatVariable": "Set Float Variable", - "GetFloatVariable": "Get Float Variable", - # Any - "SetAnyVariable": "Set Any Variable", - "GetAnyVariable": "Get Any Variable", - # Utility - "ListVariables": "List All Variables", + # Main nodes + "SetVariable": "Set Variable", + "GetVariable": "Get Variable", + "ListVariables": "List Variables", + # Deprecated + "SetImageVariable": "Set Image Variable (deprecated)", + "GetImageVariable": "Get Image Variable (deprecated)", + "SetMaskVariable": "Set Mask Variable (deprecated)", + "GetMaskVariable": "Get Mask Variable (deprecated)", + "SetLatentVariable": "Set Latent Variable (deprecated)", + "GetLatentVariable": "Get Latent Variable (deprecated)", + "SetConditioningVariable": "Set Conditioning Variable (deprecated)", + "GetConditioningVariable": "Get Conditioning Variable (deprecated)", + "SetModelVariable": "Set Model Variable (deprecated)", + "GetModelVariable": "Get Model Variable (deprecated)", + "SetClipVariable": "Set CLIP Variable (deprecated)", + "GetClipVariable": "Get CLIP Variable (deprecated)", + "SetVaeVariable": "Set VAE Variable (deprecated)", + "GetVaeVariable": "Get VAE Variable (deprecated)", + "SetStringVariable": "Set String Variable (deprecated)", + "GetStringVariable": "Get String Variable (deprecated)", + "SetIntVariable": "Set Int Variable (deprecated)", + "GetIntVariable": "Get Int Variable (deprecated)", + "SetFloatVariable": "Set Float Variable (deprecated)", + "GetFloatVariable": "Get Float Variable (deprecated)", } diff --git a/__pycache__/__init__.cpython-310.pyc b/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e66417154db12fd4aa88c7577657c31cd1ea7634 GIT binary patch literal 11234 zcmb_i-E$jP71yrTk}TVbzv8briJGKIoVre%(yug4<2sJ(Hc`^p3B;rbMR%PlktOF! zHdv&5G==iS$Mm6{p`B?S`e1nE4gLX!8F=JjXUYpR3``lI7zPN?^7|cG@~#wV?WFST z@jbieo^$TGzjOC~Y`&u-8o=+DgGVw~o(=?lN5=h&fH{GyaLNn>RA4TU3CtN&0c9xj zjes(5nR6z%pt8VO;DX>m z!3~4k25zU?1#TC(PH?+b99$e+7q|!19&mfWb%Wch_JP|6t_R$MYCpLB;CjIwPzS*s z1h*aBh&lxB5V$^Y52;abqu~0%J*>vSje#4;Aa=I-mZ2;=2pY02(1_gv8nr{9?RFS6 zW=B9f?N-okI||xsw}JNA?Vtm82k4L;10A-vf$p+9LF0B8=pMWKEyM1yd+qIZpWSZ{ zsKf7uJ}~A6XL}=d zdIoez9RnR!&w}n!$3f%jInX`o1n9VWUQMWzYEqqAw>_k$W&$HGlx|07G7F1YJAN^x zGpQ?CyAXdkK4TZ-sho;W;eRf#aBn`Ztf+(e0m{u)gFzXNfoY-#!sh;cCI)YpUCG_rkKg+P!Z3dHjA65r_YVXFOE-+ z#%G|FPo^n+Dw|K?-*|2%nsz4v%RyWxaIHN8Vj~HV45l3{C&Ddb&Qig-7G=$aRLfjg zh2|n<;Lo+HRx~;4bfS6UVWr7w1Bxm?mRoR5;9BbgpFC!C13 zZ!BfBtyT@EW%|tc)T9%dnLR(9m~z6(o=+`hi%w)=C7EG3Mogzg3QouJdZ?2O+iC!{ zgXwHRx5Jo_J1fct zRF;7U*Otzv3WWu`_-bD1PN;R-&ri-?IG-qotI8$D&rHrZky95E6SLE2(eV@Gvy)S2 z&tDR!T#iZ?inkb}18l__)kXpm?yzO>uieyqn#Se%F={7pX+n@VMf!OKwuONW!yA=gc0$*;4R~IV>Ot#6TP^OlK6pA+W`zkMGQns zIkjr)0Vr|sJiBC1YMs}(MR42|IS29J0IszVNCd#|1a|7$wC+5xqlc+!C&?}n#zNqs z<19Tu!ba%5B-DOa2t0@ftnY?^S%mIe#KHNt_&OiP@$>!p}AL>RL zWZUDk*EHLnrvxEd+EHV%F4p=<$_nV7LaAYz=@H5uA{ix-me)jtT3+Ns_I0Vh)^sH! zG+(rL4JqcSfpI>3l!TmbNW0K+BPbl)IfpgIBhV7+mFm=ofPDg@@_d;`nz$vxxU zGT7TE&L&PybGm`~qzm#K$}% z@3y?v6cB}tQs8x3lN8w9$VdM~;BZ=`B1r^t{{019Y^}eVrNbnRH%*7{QbN*UZv)G9 zeW9mVN0Q5N3C20$_uBRc_sgjLV`>m^lk<%#XY3Q%%;J`@ZE-8a1#KDUp@=i~H2!Y_ z*gvPM0&LFM-ClU&JOeS{`XZ$T*RB~mEo~LnqNow9e?cn(Yk4EOA~WWXYR=PsMg@Xu za{lp0H@jPYZ=k+FqfJ5mYf1>HIb(NQtc$h&JY@ybUtkmN7t_C?I>9t&>>ktpkiLY< zzoG(xG&$dp#sH>^DSOL^4q{u+1?UjQ>g5#o!Gid=2{`|jZVH@-ydHQW{6$Cs&0nIh zpt-ueRyYhhTLrV|X$0nvXhgu=SL2aCmgi9SL)I58lk*Qex_487Z#F)^LYqyY{4pg2 z%0pg*b#d0RKoKN=nGLvKB>$V11<8Fimi>X8LfyZzz5tn=Z#=p5EblV=V!5yj3M)Hm zvhQp1Fhxq?^&Q~I`rcX?qD~Y$x7RJQxfSi42=@zd12Xmg74PU3_z5tu7~!5h^S>5n0cP)^bib!D;N%(6W2ChHrpO zuDFW1`Z70eH<1nd*pzwbDe)cP^3vT8Kt31v__v6E@)pq27eTO@>e%nL><@CT?Vn(M0XaF}cyiGxhl;*1*IDQrsQ|g<)akS1 z^-$)*bDn3EI?u2)jqwyc6%2E|>2bmxWx#itx+KmV#J7ZDU8wpY&TJz~Ewi*PxaGRi zYuz8Y+%h^v4T4;9{*eZdJZA0o`Aeh<6K$CvX)A4);_i zW0a>l3KJb@!Zb(5#4yClGn?{EUOT~5ZUtve#-R~Y&Yhe{evt?KsciF(yN0G0IK^qV z%ug*`q5sP8?(){tfv-Un*>RH&5YkR-b#{|T2XUkFW0{vUD~7^NlLw4Adp3E*Sbx|g z4HLbBG;ijtu!pK6zT3I=yeaEzc-~Zk0~t286NU97;MVf_U(D2en#Se%(fJd&+;0Jw z;d{%ZuTf#sO!@{}T73(+4Aymn{w9^lTi{zL)y;MY5{dp83e66Ai|Cp6gSP{>aOC@* z#RK1wU_w8HTBQNkN$*&Ed^wfL^23y)@exaoef7hTa;$8oP;{*8_DZ4Q+18tkehAV$ z^c^-zTxGah=bx#sqw?1o9m!O3zJ1nl8je-6u29!yCUi)IA}A;$1Bf8W%=NWI({B1c zo5T7Mvoz?j;_0WWkQg!Ms_WpSM5>jPpIsER^c-|mf7IE6OZ;NzD&u{AniPBk$MWx+ zw*x29Pq&TNa6qrS%HMG)iy1Z2l5mWur;R~WXUJ!875LV;8n_vFC3e|-&3Mg}1Ac7H z-!yL-*VyyHADTBf$QUIP{fn)x;>w~e=kNF+#2kCXF|Iqtav8nV>~x~X*cf~jvv~ZS zN=)_zN)LHsQf=_qv1~q_$`+2JP^nkyKA6kLtK&!D^|$fhd$3tXCApE1mIDtt z;^7NL#urV%igc+PZ-er8S=BGSO5I3@+Iw6h%ZFPVVqFyDDfq^%9!izZ4P7@WS9_DI zL(ivQ8}eM=G4uni>%GOfAHOl%5aOpb-aFEw@@i{CtcPN? zH$@xfs~cjX&2vZmms!Dvl=xqBPjq2K+K>`mo;%%yQ+zy|tqK(qBRiaMGO6b_5)oT9JYBT>~wVQvpV&>nhZRW>Tm-!c~+x)ZD nYyQdFZhmC-n}4(h%s*H|=I_lNrfC}GEApYa|FhQF{^9=tTUKIc literal 0 HcmV?d00001