Upload 37 files

.gitattributes

@@ -53,3 +53,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+fonts/CALIBRI.TTF filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+Config.json

README.md

@@ -0,0 +1,48 @@
+# ComfyUI-extra-nodes - quality of life
+Extra nodes to be used in ComfyUI, including a new ChatGPT node for generating natural language responses.
+
+## ComfyUI
+ComfyUI is an advanced node-based UI that utilizes Stable Diffusion, allowing you to create customized workflows such as image post-processing or conversions.
+
+## How to install
+Download the zip file.
+Extract to ..\ComfyUI\custom_nodes.
+Restart ComfyUI if it was running (reloading the web is not enough).
+You will find my nodes under the new group O/....
+
+## How to update
+- quality of life will auto update each time you run comfyUI
+- if you want to stop autoUpdate edit  __init__.py  and set autoUpdate = false
+
+## Current nodes
+## ChatGPT
+This node harnesses the power of chatGPT, an advanced language model that can generate detailed image descriptions from a small input.
+- you need to have  OpenAI API key , which you can find at https://beta.openai.com/docs/developer-apis/overview
+- Once you have your API key, add it to the api_key.txt file
+- I have made it a separate file, so that the API key doesn't get embedded in the generated images.
+
+## String Suit
+This set of nodes adds support for string manipulation and includes a tool to generate an image from text.
+
+- String: A node that can hold a string (text).
+- Debug String: This node writes the string to the console.
+- Concat String: This node combines two strings together.
+- Trim String: This node removes any extra spaces at the start or end of a string.
+- Replace String & Replace String Advanced: These nodes replace part of the text with another part.
+### String2image
+This node generates an image based on text, which can be used with ControlNet to add text to the image. The tool supports various fonts; you can add the font you want in the fonts folder. If you load the example image in ComfyUI, the workflow that generated it will be loaded.
+
+### CLIPStringEncode
+This node is a variant of the ClipTextEncode node, but it receives the text from the string node, so you don't have to retype your prompt twice anymore.
+
+## Other tools
+### LatentUpscaleMultiply
+This node is a variant of the original LatentUpscale tool, but instead of using width and height, you use a multiply number. For example, if the original image dimensions are (512,512) and the mul values are (2,2), the result image will be (1024,1024). You can also use it to downscale by using fractions, e.g., (512,512) mul (.5,.5) → (256,256).
+
+Node Path: O/Latent/LatentUpscaleMultiply
+
+## Thanks for reading my message, and I hope that my tools will help you.
+
+## Contact
+### Discord: Omar92#3374
+### GitHub: omar92 (https://github.com/omar92)

__init__.py

@@ -0,0 +1,54 @@
+
+#----------------------------------------------------------
+#update logic
+import os
+import json
+
+
+#check if config file exists
+if not os.path.isfile(os.path.join(os.path.dirname(os.path.realpath(__file__)),"config.json")):
+    #create config file
+    config = {
+        "autoUpdate": True,
+        "branch": "main",
+        "openAI_API_Key": "sk-#########################################"
+    }
+    with open(os.path.join(os.path.dirname(os.path.realpath(__file__)),"config.json"), "w") as f:
+        json.dump(config, f, indent=4)
+
+#load config file
+with open(os.path.join(os.path.dirname(os.path.realpath(__file__)),"config.json"), "r") as f:
+    config = json.load(f)
+
+#check if autoUpdate is set
+if "autoUpdate" not in config:
+    config["autoUpdate"] = False
+
+#check if version is set
+if "version" not in config:
+    config["branch"] = "main"
+
+
+if config["autoUpdate"] == True:
+    try:
+        from .update import update as update
+        currentPath = os.path.dirname(os.path.realpath(__file__))
+        #run update/update.py to update the node class mappings
+        update.update(currentPath,branch_name=config["branch"])
+    except ImportError:
+        print("Failed to auto update `Quality of Life Suit` ")
+
+#----------------------------------------------------------
+
+from .src.QualityOfLifeSuit_Omar92 import NODE_CLASS_MAPPINGS as NODE_CLASS_MAPPINGS_SUIT
+try:
+    from .src.QualityOfLife_deprecatedNodes import NODE_CLASS_MAPPINGS as NODE_CLASS_MAPPINGS_DEPRECATED
+except ImportError:
+    NODE_CLASS_MAPPINGS_DEPRECATED = {}
+
+
+__all__ = ['NODE_CLASS_MAPPINGS_SUIT', 'NODE_CLASS_MAPPINGS_DEPRECATED', 'NODE_CLASS_MAPPINGS']
+NODE_CLASS_MAPPINGS = {
+    **NODE_CLASS_MAPPINGS_SUIT,
+    **NODE_CLASS_MAPPINGS_DEPRECATED
+}

config.json

@@ -0,0 +1,5 @@
+{
+    "autoUpdate": true,
+    "branch": "main",
+    "openAI_API_Key": "sk-#########################################"
+}

fonts/CALIBRI.TTF

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df2c69a18a462e5cbc97d04a033f3bd7cd0abfe818381641f8c2dee7b7c43dbd
+size 1681220

src/QualityOfLifeSuit_Omar92.py

@@ -0,0 +1,1271 @@
+# Developed by Omar - https://github.com/omar92
+# https://civitai.com/user/omar92
+# discord: Omar92#3374
+
+import io
+import json
+import os
+import random
+import time
+from urllib.request import urlopen
+import numpy as np
+import requests
+import torch
+from PIL import Image, ImageFont, ImageDraw
+import importlib
+import comfy.samplers
+import comfy.sd
+import comfy.utils
+import torch.nn as nn
+
+MAX_RESOLUTION = 8192
+
+# region INSTALLATION CLEANUP (thanks WAS i got this from you)
+# Delete legacy nodes
+legacy_nodes = ['ChatGPT_Omar92.py',
+                'LatentUpscaleMultiply_Omar92.py', 'StringSuit_Omar92.py']
+legacy_nodes_found = []
+f_disp = False
+for f in legacy_nodes:
+    node_path_dir = os.getcwd()+'/ComfyUI/custom_nodes/'
+    file = f'{node_path_dir}{f}'
+    if os.path.exists(file):
+        import zipfile
+        if not f_disp:
+            print(
+                '\033[33mQualityOflife Node Suite:\033[0m Found legacy nodes. Archiving legacy nodes...')
+            f_disp = True
+        legacy_nodes_found.append(file)
+if legacy_nodes_found:
+    from os.path import basename
+    archive = zipfile.ZipFile(
+        f'{node_path_dir}QualityOflife_Backup_{round(time.time())}.zip', "w")
+    for f in legacy_nodes_found:
+        archive.write(f, basename(f))
+        try:
+            os.remove(f)
+        except OSError:
+            pass
+    archive.close()
+if f_disp:
+    print('\033[33mQualityOflife Node Suite:\033[0m Legacy cleanup complete.')
+# endregion
+
+# region global
+PACKAGE_NAME = '\033[33mQualityOfLifeSuit_Omar92:\033[0m'
+NODE_FILE = os.path.abspath(__file__)
+SUIT_DIR = (os.path.dirname(os.path.dirname(NODE_FILE))
+                    if os.path.dirname(os.path.dirname(NODE_FILE)) == 'QualityOfLifeSuit_Omar92'
+                    or os.path.dirname(os.path.dirname(NODE_FILE)) == 'QualityOfLifeSuit_Omar92-dev'
+                    else os.path.dirname(NODE_FILE))
+SUIT_DIR = SUIT_DIR+"\\.."
+print(f'\033[33mQualityOfLifeSuit_Omar92_DIR:\033[0m {SUIT_DIR}')
+
+
+def enforce_mul_of_64(d):
+    leftover = d % 8          # 8 is the number of pixels per byte
+    if leftover != 0:         # if the number of pixels is not a multiple of 8
+        if (leftover < 4):       # if the number of pixels is less than 4
+            d -= leftover     # remove the leftover pixels
+        else:                 # if the number of pixels is more than 4
+            d += 8 - leftover  # add the leftover pixels
+
+    return d
+
+# endregion
+
+
+# region openAITools
+
+
+def install_openai():
+    # Helper function to install the OpenAI module if not already installed
+    try:
+        importlib.import_module('openai')
+    except ImportError:
+        import pip
+        pip.main(['install', 'openai'])
+
+
+def get_api_key():
+    # Helper function to get the API key from the file
+    try:
+        #open config file  
+        configPath  =  os.path.join(SUIT_DIR, "config.json")
+        with open(configPath, 'r') as f:  # Open the file and read the API key
+            config = json.load(f)
+        api_key = config["openAI_API_Key"]
+    except:
+        print("Error: OpenAI API key file not found OpenAI features wont work for you")
+        return ""
+    return api_key  # Return the API key
+
+
+openAI_models = None
+
+
+def get_openAI_models():
+    global openAI_models
+    if (openAI_models != None):
+        return openAI_models
+
+    install_openai()
+    import openai
+    # Set the API key for the OpenAI module
+    openai.api_key = get_api_key()
+
+    try:
+        models = openai.Model.list()  # Get the list of models
+    except:
+        print("Error: OpenAI API key is invalid OpenAI features wont work for you")
+        return []
+
+    openAI_models = []  # Create a list for the chat models
+    for model in models["data"]:  # Loop through the models
+        openAI_models.append(model["id"])  # Add the model to the list
+
+    return openAI_models  # Return the list of chat models
+
+
+openAI_gpt_models = None
+
+
+def get_gpt_models():
+    global openAI_gpt_models
+    if (openAI_gpt_models != None):
+        return openAI_gpt_models
+    models = get_openAI_models()
+    openAI_gpt_models = []  # Create a list for the chat models
+    for model in models:  # Loop through the models
+        if ("gpt" in model.lower()):
+            openAI_gpt_models.append(model)
+
+    return openAI_gpt_models  # Return the list of chat models
+
+
+class O_ChatGPT_O:
+    """
+    this node is based on the openAI GPT-3 API to generate propmpts using the AI
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # Multiline string input for the prompt
+                "prompt": ("STRING", {"multiline": True}),
+                "model": (get_gpt_models(), {"default": "gpt-3.5-turbo"}),
+            },
+            "optional": {
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)  # Define the return type of the node
+    FUNCTION = "fun"  # Define the function name for the node
+    CATEGORY = "O >>/OpenAI >>"  # Define the category for the node
+
+    def fun(self,  model, prompt, seed):
+        install_openai()  # Install the OpenAI module if not already installed
+        import openai  # Import the OpenAI module
+
+        # Get the API key from the file
+        api_key = get_api_key()
+
+        openai.api_key = api_key  # Set the API key for the OpenAI module
+
+        # Create a chat completion using the OpenAI module
+        completion = openai.ChatCompletion.create(
+            model=model,
+            messages=[
+                {"role": "user", "content": "act as prompt generator ,i will give you text and you describe an image that match that text in details, answer with one response only"},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        # Get the answer from the chat completion
+        answer = completion["choices"][0]["message"]["content"]
+        return (answer,)  # Return the answer as a string
+# region advanced
+
+
+class load_openAI_O:
+    """
+    this node will load  openAI model
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+            }
+        }
+    RETURN_TYPES = ("OPENAI",)  # Define the return type of the node
+    FUNCTION = "fun"  # Define the function name for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>"  # Define the category for the node
+
+    def fun(self):
+        install_openai()  # Install the OpenAI module if not already installed
+        import openai  # Import the OpenAI module
+
+        # Get the API key from the file
+        api_key = get_api_key()
+        openai.api_key = api_key  # Set the API key for the OpenAI module
+
+        return (
+            {
+                "openai": openai,  # Return openAI model
+            },
+        )
+# region ChatGPT
+
+
+class openAi_chat_message_O:
+    """
+    create chat message for openAI chatGPT
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "role": (["user", "assistant", "system"], {"default": "user"}),
+                "content": ("STRING", {"multiline": True, "default": "act as prompt generator ,i will give you text and you describe an image that match that text in details, answer with one response only"}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("OPENAI_CHAT_MESSAGES",)
+    FUNCTION = "fun"  # Define the function name for the node
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, role, content):
+        return (
+            {
+                "messages": [{"role": role, "content": content, }]
+            },
+        )
+
+
+class openAi_chat_messages_Combine_O:
+    """
+     compine chat messages into 1 tuple
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "message1": ("OPENAI_CHAT_MESSAGES", ),
+                "message2": ("OPENAI_CHAT_MESSAGES", ),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("OPENAI_CHAT_MESSAGES",)
+    FUNCTION = "fun"  # Define the function name for the node
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, message1, message2):
+        messages = message1["messages"] + \
+            message2["messages"]  # compine messages
+
+        return (
+            {
+                "messages": messages
+            },
+        )
+
+
+class openAi_chat_completion_O:
+    """
+    create chat completion for openAI chatGPT
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                # "model": ("STRING", {"multiline": False, "default": "gpt-3.5-turbo"}),
+                "model": (get_gpt_models(), {"default": "gpt-3.5-turbo"}),
+                "messages": ("OPENAI_CHAT_MESSAGES", ),
+            },
+            "optional": {
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("STRING", "OPENAI_CHAT_COMPLETION",)
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, openai, model, messages, seed):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        completion = openai.ChatCompletion.create(
+            model=model,
+            messages=messages["messages"]
+        )
+        # Get the answer from the chat completion
+        content = completion["choices"][0]["message"]["content"]
+        return (
+            content,  # Return the answer as a string
+            completion,  # Return the chat completion
+        )
+
+
+class DebugOpenAIChatMEssages_O:
+    """
+    Debug OpenAI Chat Messages
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "messages": ("OPENAI_CHAT_MESSAGES", ),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ()
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, messages):
+        print(f'{PACKAGE_NAME}:OpenAIChatMEssages', messages["messages"])
+        return ()
+
+
+class DebugOpenAIChatCompletion_O:
+    """
+    Debug OpenAI Chat Completion
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "completion": ("OPENAI_CHAT_COMPLETION", ),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ()
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, completion):
+        print(f'{PACKAGE_NAME}:OpenAIChatCompletion:', completion)
+        return ()
+# endregion ChatGPT
+# region Image
+
+
+class openAi_Image_create_O:
+    """
+    create image using openai
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                "prompt": ("STRING", {"multiline": True}),
+                "number": ("INT", {"default": 1, "min": 1, "max": 10,  "step": 1}),
+                "size": (["256x256", "512x512", "1024x1024"], {"default": "256x256"}),
+            },
+            "optional": {
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/Image >>"
+
+    def fun(self, openai, prompt, number, size, seed):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        prompt = prompt
+        number = 1
+
+        imageURL = ""
+        try:
+            imagesURLS = openai.Image.create(
+                prompt=prompt,
+                n=number,
+                size=size
+            )
+            imageURL = imagesURLS["data"][0]["url"]
+        except Exception as e:
+            print(f'{PACKAGE_NAME}:openAi_Image_create_O:', e)
+            imageURL = "https://i.imgur.com/removed.png"
+           
+
+        image = requests.get(imageURL).content
+        i = Image.open(io.BytesIO(image))
+        image = i.convert("RGBA")
+        image = np.array(image).astype(np.float32) / 255.0
+        # image_np = np.transpose(image_np, (2, 0, 1))
+        image = torch.from_numpy(image)[None,]
+        if 'A' in i.getbands():
+            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+            mask = 1. - torch.from_numpy(mask)
+        else:
+            mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+        return (image, mask)
+
+
+class openAi_Image_Edit_O:
+    """
+    edit an image using openai
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                "image": ("IMAGE",),
+                "prompt": ("STRING", {"multiline": True}),
+                "number": ("INT", {"default": 1, "min": 1, "max": 10,  "step": 1}),
+                "size": (["256x256", "512x512", "1024x1024"], {"default": "256x256"}),
+            },
+            "optional": {
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/Image >>"
+
+    def fun(self, openai, image, prompt, number, size, seed):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        prompt = prompt
+        number = 1
+
+    # Convert PyTorch tensor to NumPy array
+        image = image[0]
+        i = 255. * image.cpu().numpy()
+        img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        # Save the image to a BytesIO object as a PNG file
+        with io.BytesIO() as output:
+            img.save(output, format='PNG')
+            binary_image = output.getvalue()
+
+        # Create a circular mask with alpha 0 in the middle
+        mask = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
+        center = (image.shape[1] // 2, image.shape[0] // 2)
+        radius = min(center[0], center[1])
+        draw = ImageDraw.Draw(Image.fromarray(mask, mode='RGBA'))
+        draw.ellipse((center[0]-radius, center[1]-radius, center[0]+radius,
+                     center[1]+radius), fill=(0, 0, 0, 255), outline=(0, 0, 0, 0))
+        del draw
+        # Save the mask to a BytesIO object as a PNG file
+        with io.BytesIO() as output:
+            Image.fromarray(mask, mode='RGBA').save(output, format='PNG')
+            binary_mask = output.getvalue()
+
+        imageURL = ""
+        try:
+            imagesURLS = openai.Image.create_edit(
+                image=binary_image,
+                mask=binary_mask,
+                prompt=prompt,
+                n=number,
+                size=size
+            )
+            imageURL = imagesURLS["data"][0]["url"]
+        except Exception as e:
+            print(f'{PACKAGE_NAME}:openAi_Image_create_O:', e)
+            imageURL = "https://i.imgur.com/removed.png"
+
+        image = requests.get(imageURL).content
+        i = Image.open(io.BytesIO(image))
+        image = i.convert("RGBA")
+        image = np.array(image).astype(np.float32) / 255.0
+        # image_np = np.transpose(image_np, (2, 0, 1))
+        image = torch.from_numpy(image)[None,]
+        if 'A' in i.getbands():
+            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+            mask = 1. - torch.from_numpy(mask)
+        else:
+            mask = torch.zeros(
+                (1, image.shape[2], image.shape[3]), dtype=torch.float32, device="cpu")
+        return (image, mask)
+
+
+class openAi_Image_variation_O:
+    """
+    edit an image using openai
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                "image": ("IMAGE",),
+                "number": ("INT", {"default": 1, "min": 1, "max": 10,  "step": 1}),
+                "size": (["256x256", "512x512", "1024x1024"], {"default": "256x256"}),
+            },
+            "optional": {
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>/Image >>"
+
+    def fun(self, openai, image, number, size, seed):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        number = 1
+
+    # Convert PyTorch tensor to NumPy array
+        image = image[0]
+        i = 255. * image.cpu().numpy()
+        img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        # Save the image to a BytesIO object as a PNG file
+        with io.BytesIO() as output:
+            img.save(output, format='PNG')
+            binary_image = output.getvalue()
+
+        imageURL = " "
+        try:
+            imagesURLS = openai.Image.create_variation(
+                image=binary_image,
+                n=number,
+                size=size
+            )
+            imageURL = imagesURLS["data"][0]["url"]
+        except Exception as e:
+            print(f'{PACKAGE_NAME}:openAi_Image_create_O:', e)
+            imageURL = "https://i.imgur.com/removed.png"
+
+        image = requests.get(imageURL).content
+        i = Image.open(io.BytesIO(image))
+        image = i.convert("RGBA")
+        image = np.array(image).astype(np.float32) / 255.0
+        # image_np = np.transpose(image_np, (2, 0, 1))
+        image = torch.from_numpy(image)[None,]
+        if 'A' in i.getbands():
+            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+            mask = 1. - torch.from_numpy(mask)
+        else:
+            mask = torch.zeros(
+                (1, image.shape[2], image.shape[3]), dtype=torch.float32, device="cpu")
+        return (image, mask)
+# endregion Image
+# endregion advanced
+# endregion openAI
+
+# region latentTools
+
+
+class LatentUpscaleFactor_O:
+    """
+    Upscale the latent code by multiplying the width and height by a factor
+    """
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "samples": ("LATENT",),
+                "upscale_method": (cls.upscale_methods,),
+                "WidthFactor": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.28125}),
+                "HeightFactor": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step":  0.28125}),
+                "crop": (cls.crop_methods,),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "upscale"
+    CATEGORY = "O >>/latent >>"
+
+    def upscale(self, samples, upscale_method, WidthFactor, HeightFactor, crop):
+        s = samples.copy()
+        x = samples["samples"].shape[3]
+        y = samples["samples"].shape[2]
+
+        new_x = int(x * WidthFactor)
+        new_y = int(y * HeightFactor)
+
+        if (new_x > MAX_RESOLUTION):
+            new_x = MAX_RESOLUTION
+        if (new_y > MAX_RESOLUTION):
+            new_y = MAX_RESOLUTION
+
+        print(f'{PACKAGE_NAME}:upscale from ({x*8},{y*8}) to ({new_x*8},{new_y*8})')
+
+        s["samples"] = comfy.utils.common_upscale(
+            samples["samples"], enforce_mul_of_64(
+                new_x), enforce_mul_of_64(new_y), upscale_method, crop
+        )
+        return (s,)
+
+
+class SelectLatentImage_O:
+    """
+    Select a single image from a batch of generated latent images.
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "samples": ("LATENT",),
+                "index": ("INT", {"default": 0, "min": 0}),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/latent >>"
+
+    def fun(self, samples, index):
+        # Get the batch size and number of channels
+        batch_size, num_channels, height, width = samples["samples"].shape
+
+        # Ensure that the index is within bounds
+        if index >= batch_size:
+            index = batch_size - 1
+
+        # Select the specified image
+        selected_image = samples["samples"][index].unsqueeze(0)
+
+        # Return the selected image
+        return ({"samples": selected_image},)
+
+
+class VAEDecodeParallel_O:
+    def __init__(self, device="cpu"):
+        self.device = device
+        self.device_count = torch.cuda.device_count() if device != "cpu" else 1
+        self.module = VAEDecodeOriginal(device)
+        self.net = nn.DataParallel(self.module)
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"samples": ("LATENT", ), "vae": ("VAE", )}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "decode_parallel"
+    CATEGORY = "latent"
+
+    def decode_parallel(self, vae, samples):
+        batch_size = samples["samples"].shape[0]
+        images = torch.zeros((batch_size, 3, 256, 256)).to(self.device)
+
+        for i in range(0, batch_size, self.device_count):
+            batch_samples = samples["samples"][i:i +
+                                               self.device_count].to(self.device)
+            batch_images = self.net(vae, {"samples": batch_samples})[
+                0].to(self.device)
+            images[i:i+self.device_count] = batch_images
+
+        return (images,)
+
+
+class VAEDecodeOriginal:
+    def __init__(self, device="cpu"):
+        self.device = device
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"samples": ("LATENT", ), "vae": ("VAE", )}}
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "decode"
+
+    CATEGORY = "latent"
+
+    def decode(self, vae, samples):
+        return (vae.decode(samples["samples"]), )
+
+# endregion latentTools
+
+# region TextTools
+
+
+class seed2String_O:
+    """
+    This node convert seeds to string // can be used to force the system to read a string again if it got compined with it 
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"seed": ("SEED")}}
+
+    RETURN_TYPES = ("STRING")
+    FUNCTION = "fun"
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, seed):
+        return (str(seed))
+
+
+class DebugText_O:
+    """
+    This node will write a text to the console
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text": ("STRING", {"multiline": True}),
+            "prefix": ("STRING", {"default": "debug", "multiline": False}),
+        }}
+
+    RETURN_TYPES = ()
+    FUNCTION = "debug_string"
+    OUTPUT_NODE = True
+    CATEGORY = "O >>/text >>"
+
+    @staticmethod
+    def debug_string(text, prefix):
+        print(f'{PACKAGE_NAME}:{prefix}:{text}')
+        return ()
+
+
+fonts = None
+
+
+def loadFonts():
+
+    global fonts
+    if (fonts != None):
+        return fonts
+    try:
+        fonts_filepath = os.path.join(SUIT_DIR, "fonts")
+        fonts = []
+        for file in os.listdir(fonts_filepath):
+            if file.endswith(".ttf") or file.endswith(".otf") or file.endswith(".ttc") or file.endswith(".TTF") or file.endswith(".OTF") or file.endswith(".TTC"):
+                fonts.append(file)
+    except:
+        fonts = []
+
+        if (len(fonts) == 0):
+            print(f'{PACKAGE_NAME}:no fonts found in {fonts_filepath}')
+            fonts = ["Arial.ttf"]
+    return fonts
+
+
+class Text2Image_O:
+    """
+    This node will convert a string to an image
+    """
+
+    def __init__(self):
+        self.font_filepath = os.path.join(SUIT_DIR, "fonts")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"multiline": True}),
+                "font": (loadFonts(), {"default": loadFonts()[0], }),
+                "size": ("INT", {"default": 36, "min": 0, "max": 255, "step": 1}),
+                "font_R": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "font_G": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "font_B": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "font_A": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_R": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_G": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_B": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_A": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "width": ("INT", {"default": 128, "min": 0,  "step": 1}),
+                "height": ("INT", {"default": 128, "min": 0,  "step": 1}),
+                "expand": (["true", "false"], {"default": "true"}),
+                "x": ("INT", {"default": 0, "min": -100, "step": 1}),
+                "y": ("INT", {"default": 0, "min": -100, "step": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "create_image_new"
+    OUTPUT_NODE = False
+    CATEGORY = "O >>/text >>"
+
+    def create_image_new(self, text, font, size, font_R, font_G, font_B, font_A, background_R, background_G, background_B, background_A, width, height, expand, x, y):
+        font_color = (font_R, font_G, font_B, font_A)
+        background_color = (background_R, background_G,
+                            background_B, background_A)
+
+        font_path = os.path.join(self.font_filepath, font)
+        font = ImageFont.truetype(font_path, size)
+
+        # Initialize the drawing context
+        image = Image.new('RGBA', (1, 1), color=background_color)
+        draw = ImageDraw.Draw(image)
+
+        # Get the size of the text
+        text_width, text_height = draw.textsize(text, font=font)
+
+        # Set the dimensions of the image
+        if expand == "true":
+            if width < text_width:
+                width = text_width
+            if height < text_height:
+                height = text_height
+
+        width = enforce_mul_of_64(width)
+        height = enforce_mul_of_64(height)
+
+        # Create a new image
+        image = Image.new('RGBA', (width, height), color=background_color)
+
+        # Initialize the drawing context
+        draw = ImageDraw.Draw(image)
+
+        # Calculate the position of the text
+        text_x = x - text_width/2
+        if (text_x < 0):
+            text_x = 0
+        if (text_x > width-text_width):
+            text_x = width - text_width
+
+        text_y = y - text_height/2
+        if (text_y < 0):
+            text_y = 0
+        if (text_y > height-text_height):
+            text_y = height - text_height
+
+        # Draw the text on the image
+        draw.text((text_x, text_y), text, fill=font_color, font=font)
+
+        # Convert the PIL Image to a tensor
+        image_np = np.array(image).astype(np.float32) / 255.0
+        image_tensor = torch.from_numpy(image_np).unsqueeze(0)
+        return image_tensor, {"ui": {"images": image_tensor}}
+# region text/NSP
+
+
+nspterminology = None  # Cache the NSP terminology
+
+
+def laodNSP():
+    global nspterminology
+    if (nspterminology != None):
+        return nspterminology
+    # Fetch the NSP Pantry
+    local_pantry = os.getcwd()+'/ComfyUI/custom_nodes/nsp_pantry.json'
+    if not os.path.exists(local_pantry):
+        print(f'{PACKAGE_NAME}:downlaoding NSP')
+        response = urlopen(
+            'https://raw.githubusercontent.com/WASasquatch/noodle-soup-prompts/main/nsp_pantry.json')
+        tmp_pantry = json.loads(response.read())
+        # Dump JSON locally
+        pantry_serialized = json.dumps(tmp_pantry, indent=4)
+        with open(local_pantry, "w") as f:
+            f.write(pantry_serialized)
+        del response, tmp_pantry
+
+    # Load local pantry
+    with open(local_pantry, 'r') as f:
+        nspterminology = json.load(f)
+
+    print(f'{PACKAGE_NAME}:NSP ready')
+    return nspterminology
+
+
+class RandomNSP_O:
+    @classmethod
+    def laodCategories(s):
+        nspterminology = laodNSP()
+        terminologies = []
+        for term in nspterminology:
+            terminologies.append(term)
+
+        return (terminologies)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "terminology": (s.laodCategories(),),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }}
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+
+    CATEGORY = "O >>/text >>/NSP >>"
+
+    def fun(self, terminology, seed):
+
+        nspterminology = laodNSP()
+        # Set the seed
+        random.seed(seed)
+
+        result = random.choice(nspterminology[terminology])
+        return (result, {"ui": {"STRING": result}})
+
+# endregion text/NSP
+
+# region text/operations
+
+
+class concat_text_O:
+    """
+    This node will concatenate two strings together
+    """
+    @ classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text1": ("STRING", {"multiline": True}),
+            "separator": ("STRING", {"multiline": False, "default": ","}),
+            "text2": ("STRING", {"multiline": True})
+        }}
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/text >>/operations >>"
+
+    @ staticmethod
+    def fun(text1, separator, text2):
+        return (text1 + separator + text2,)
+
+
+class trim_text_O:
+    """
+    This node will trim a string from the left and right
+    """
+    @ classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text": ("STRING", {"multiline": True}),
+        }}
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/text >>/operations >>"
+
+    def fun(self, text):
+        return (text.strip(),)
+
+
+class replace_text_O:
+    """
+    This node will replace a string with another string
+    """
+    @ classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text": ("STRING", {"multiline": True}),
+            "old": ("STRING", {"multiline": False}),
+            "new": ("STRING", {"multiline": False})
+        }}
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/text >>/operations >>"
+
+    @ staticmethod
+    def fun(text, old, new):
+        return (text.replace(old, new),)  # replace a text with another text
+# endregion
+# endregion TextTools
+
+# region Image
+
+
+class ImageScaleFactor_O:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+    toggle = ["enabled", "disabled"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"image": ("IMAGE",),
+                             "upscale_method": (s.upscale_methods,),
+                             "WidthFactor": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.28125}),
+                             "HeightFactor": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.28125}),
+                             "MulOf46": (s.toggle, {"default": "enabled"}),
+                             "crop": (s.crop_methods,)
+                             }}
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "upscale"
+
+    CATEGORY = "O >>/image >>"
+
+    def upscale(self, image, upscale_method, WidthFactor, HeightFactor, crop, MulOf46):
+        samples = image.movedim(-1, 1)
+        width = WidthFactor * samples.shape[2]
+        height = HeightFactor * samples.shape[3]
+        if (width > MAX_RESOLUTION):
+            width = MAX_RESOLUTION
+        if (height > MAX_RESOLUTION):
+            height = MAX_RESOLUTION
+
+        if (MulOf46 == "enabled"):
+            width = enforce_mul_of_64(width)
+            height = enforce_mul_of_64(height)
+
+        width = int(width)
+        height = int(height)
+        print(
+            f'{PACKAGE_NAME}:upscale from ({samples.shape[2]},{samples.shape[3]}) to ({width},{height})')
+        s = comfy.utils.common_upscale(
+            samples, width, height, upscale_method, crop)
+        s = s.movedim(1, -1)
+        return (s,)
+# endregion
+
+# region numbers
+
+
+def solveEquation(equation):
+    answer = 0.0
+    # Check if v is a valid equation or a number using regular expressions
+    try:
+        # Solve the equation using Python's built-in eval function
+        answer = eval(equation)
+    except Exception as e:
+        print(f'{PACKAGE_NAME}: equation is not valid: {equation} error: {e}')
+        answer = "NAN"
+
+    return answer
+
+
+class applyEquation1param_O:
+    """
+    This node generate seeds for the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "x": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}),
+            "equation": ("STRING", {"multiline": True, "default": "x+1"}),
+        }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/numbers >>"
+
+    def fun(self, x, equation):
+        equation = equation.replace("x", "("+str(x)+")")
+        answer = solveEquation(equation)
+        return (answer,)
+
+
+class applyEquation2params_O:
+    """
+    This node generate seeds for the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "x": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}),
+            "y": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}),
+            "equation": ("STRING", {"multiline": True, "default": "x+y"}),
+        }}
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/numbers >>"
+
+    def fun(self, x, y, equation):
+        equation = equation.replace("x", "("+str(x)+")")
+        equation = equation.replace("y", "("+str(y)+")")
+        answer = solveEquation(equation)
+        return (answer,)
+
+
+class floatToInt_O:
+    """
+    This node convert float to int
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "float": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}),
+        }
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/numbers >>"
+
+    def fun(self, float):
+        return (int(float),)
+
+
+class intToFloat_O:
+    """
+    This node convert int to float
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "int": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/numbers >>"
+
+    def fun(self, int):
+        return (float(int),)
+
+
+class floatToText_O:
+    """
+    This node convert float to text
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "float": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}),
+        }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/numbers >>"
+
+    def fun(self, float):
+        return (str(float),)
+# endregion
+
+# region Utils
+
+
+class Text_O:
+    """
+    to provide text to the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": ("STRING", {"multiline": True}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, text):
+        return (text+" ",)
+
+
+class seed_O:
+    """
+    This node generate seeds for the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), }}
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, seed):
+        return (seed,)
+
+
+class int_O:
+    """
+    This node generate seeds for the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"int": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), }}
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, int):
+        return (int,)
+
+
+class float_O:
+    """
+    This node generate seeds for the model
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"float": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff}), }}
+
+    RETURN_TYPES = ("FLOAT",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, float):
+        return (float,)
+
+
+class Note_O:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"text": ("STRING", {"multiline": True})}}
+    RETURN_TYPES = ()
+    FUNCTION = "fun"
+    OUTPUT_NODE = True
+    CATEGORY = "O >>/utils >>"
+
+    def fun(self, text):
+        return ()
+# endregion
+
+
+# Define the node class mappings
+NODE_CLASS_MAPPINGS = {
+    # openAITools------------------------------------------
+    "ChatGPT Simple _O": O_ChatGPT_O,
+    # openAiTools > Advanced
+    "load_openAI _O": load_openAI_O,
+    # openAiTools > Advanced > ChatGPT
+    "Chat_Message _O": openAi_chat_message_O,
+    "combine_chat_messages _O": openAi_chat_messages_Combine_O,
+    "Chat completion _O": openAi_chat_completion_O,
+    "debug messages_O": DebugOpenAIChatMEssages_O,
+    "debug Completeion _O": DebugOpenAIChatCompletion_O,
+    # openAiTools > Advanced > image
+    "create image _O": openAi_Image_create_O,
+    # "Edit_image _O": openAi_Image_Edit, # coming soon
+    "variation_image _O": openAi_Image_variation_O,
+    # latentTools------------------------------------------
+    "LatentUpscaleFactor _O": LatentUpscaleFactor_O,
+    "selectLatentFromBatch _O": SelectLatentImage_O,
+    # "VAEDecodeParallel _O": VAEDecodeParallel_O, # coming soon
+    # StringTools------------------------------------------
+    "Debug Text _O": DebugText_O,
+    "RandomNSP _O": RandomNSP_O,
+    "Concat Text _O": concat_text_O,
+    "Trim Text _O": trim_text_O,
+    "Replace Text _O": replace_text_O,
+    "Text2Image _O": Text2Image_O,
+    # ImageTools------------------------------------------
+    "ImageScaleFactor _O": ImageScaleFactor_O,
+    # NumberTools------------------------------------------
+    "Equation1param _O": applyEquation1param_O,
+    "Equation2params _O": applyEquation2params_O,
+    "floatToInt _O": floatToInt_O,
+    "intToFloat _O": intToFloat_O,
+    "floatToText _O": floatToText_O,
+    # Utils------------------------------------------
+    "Note _O": Note_O,
+    "Text _O": Text_O,
+    "seed _O": seed_O,
+    "int _O": int_O,
+    "float _O": float_O,
+}

src/QualityOfLife_deprecatedNodes.py

@@ -0,0 +1,543 @@
+# Developed by Omar - https://github.com/omar92
+# https://civitai.com/user/omar92
+# discord: Omar92#3374
+
+###
+#
+#  All nodes in this file are deprecated and will be removed in the future , i left them here for backward compatibility
+#
+###
+
+import io
+import os
+import time
+import numpy as np
+import requests
+import torch
+from PIL import Image, ImageFont, ImageDraw
+from PIL import Image, ImageDraw
+import importlib
+import comfy.samplers
+import comfy.sd
+import comfy.utils
+
+# -------------------------------------------------------------------------------------------
+# region deprecated
+# region openAITools
+
+
+class O_ChatGPT_deprecated:
+    """
+    this node is based on the openAI GPT-3 API to generate propmpts using the AI
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # Multiline string input for the prompt
+                "prompt": ("STRING", {"multiline": True}),
+                # File input for the API key
+                "api_key_file": ("STRING", {"file": True, "default": "api_key.txt"})
+            }
+        }
+
+    RETURN_TYPES = ("STR",)  # Define the return type of the node
+    FUNCTION = "fun"  # Define the function name for the node
+    CATEGORY = "O >>/deprecated >>/OpenAI >>"  # Define the category for the node
+
+    def fun(self, api_key_file, prompt):
+        self.install_openai()  # Install the OpenAI module if not already installed
+        import openai  # Import the OpenAI module
+
+        # Get the API key from the file
+        api_key = self.get_api_key(api_key_file)
+
+        openai.api_key = api_key  # Set the API key for the OpenAI module
+
+        # Create a chat completion using the OpenAI module
+        completion = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "user", "content": "act as prompt generator ,i will give you text and you describe an image that match that text in details, answer with one response only"},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        # Get the answer from the chat completion
+        answer = completion["choices"][0]["message"]["content"]
+
+        return (
+            {
+                "string": answer,  # Return the answer as a string
+            },
+        )
+
+    # Helper function to get the API key from the file
+    def get_api_key(self, api_key_file):
+        custom_nodes_dir = 'ComfyUI/custom_nodes/'  # Define the directory for the file
+        with open(custom_nodes_dir+api_key_file, 'r') as f:  # Open the file and read the API key
+            api_key = f.read().strip()
+        return api_key  # Return the API key
+
+    # Helper function to install the OpenAI module if not already installed
+    def install_openai(self):
+        try:
+            importlib.import_module('openai')
+        except ImportError:
+            import pip
+            pip.main(['install', 'openai'])
+# region advanced
+
+    """
+    this node will load  openAI model
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # File input for the API key
+                "api_key_file": ("STRING", {"file": True, "default": "api_key.txt"})
+            }
+        }
+    RETURN_TYPES = ("OPENAI",)  # Define the return type of the node
+    FUNCTION = "fun"  # Define the function name for the node
+    CATEGORY = "O >>/OpenAI >>/Advanced >>"  # Define the category for the node
+
+    def fun(self, api_key_file):
+        self.install_openai()  # Install the OpenAI module if not already installed
+        import openai  # Import the OpenAI module
+
+        # Get the API key from the file
+        api_key = self.get_api_key(api_key_file)
+        openai.api_key = api_key  # Set the API key for the OpenAI module
+
+        return (
+            {
+                "openai": openai,  # Return openAI model
+            },
+        )
+
+    # Helper function to install the OpenAI module if not already installed
+    def install_openai(self):
+        try:
+            importlib.import_module('openai')
+        except ImportError:
+            import pip
+            pip.main(['install', 'openai'])
+
+    # Helper function to get the API key from the file
+    def get_api_key(self, api_key_file):
+        custom_nodes_dir = 'ComfyUI/custom_nodes/'  # Define the directory for the file
+        with open(custom_nodes_dir+api_key_file, 'r') as f:  # Open the file and read the API key
+            api_key = f.read().strip()
+        return api_key  # Return the API key
+# region ChatGPT
+
+
+class openAi_chat_message_STR_deprecated:
+    """
+    create chat message for openAI chatGPT
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "role": (["user", "assistant", "system"], {"default": "user"}),
+                "content": ("STR",),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("OPENAI_CHAT_MESSAGES",)
+    FUNCTION = "fun"  # Define the function name for the node
+    # Define the category for the node
+    CATEGORY = "O >>/deprecated >>/OpenAI >>/Advanced >>/ChatGPT"
+
+    def fun(self, role, content):
+        return (
+            {
+                "messages": [{"role": role, "content": content["string"], }]
+            },
+        )
+# endregion ChatGPT
+# region Image
+
+class openAi_chat_messages_Combine_deprecated:
+    """
+     compine chat messages into 1 tuple
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "message1": ("OPENAI_CHAT_MESSAGES", ),
+                "message2": ("OPENAI_CHAT_MESSAGES", ),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("OPENAI_CHAT_MESSAGES",)
+    FUNCTION = "fun"  # Define the function name for the node
+    # Define the category for the node
+    CATEGORY = "O >>/deprecated >>/OpenAI >>/Advanced >>/ChatGPT >>"
+
+    def fun(self, message1, message2):
+        messages = message1["messages"] + \
+            message2["messages"]  # compine messages
+
+        return (
+            {
+                "messages": messages
+            },
+        )
+class openAi_Image_create_deprecated:
+    """
+    create image using openai 
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                "prompt": ("STR",),
+                "number": ("INT", {"default": 1, "min": 1, "max": 10,  "step": 1}),
+                "size": (["256x256", "512x512", "1024x1024"], {"default": "256x256"}),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/deprecated >>/OpenAI >>/Advanced >>/Image"
+
+    def fun(self, openai, prompt, number, size):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        prompt = prompt["string"]
+        number = 1
+        imagesURLS = openai.Image.create(
+            prompt=prompt,
+            n=number,
+            size=size
+        )
+        imageURL = imagesURLS["data"][0]["url"]
+        print("imageURL:", imageURL)
+        image = requests.get(imageURL).content
+        i = Image.open(io.BytesIO(image))
+        image = i.convert("RGBA")
+        image = np.array(image).astype(np.float32) / 255.0
+        # image_np = np.transpose(image_np, (2, 0, 1))
+        image = torch.from_numpy(image)[None,]
+        if 'A' in i.getbands():
+            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+            mask = 1. - torch.from_numpy(mask)
+        else:
+            mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+        print("image_tensor: done")
+        return (image, mask)
+
+
+class openAi_chat_completion_deprecated:
+    """
+    create chat completion for openAI chatGPT
+    """
+    # Define the input types for the node
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "openai": ("OPENAI", ),
+                "model": ("STRING", {"multiline": False, "default": "gpt-3.5-turbo"}),
+                "messages": ("OPENAI_CHAT_MESSAGES", ),
+            }
+        }
+    # Define the return type of the node
+    RETURN_TYPES = ("STR", "OPENAI_CHAT_COMPLETION",)
+    FUNCTION = "fun"  # Define the function name for the node
+    OUTPUT_NODE = True
+    # Define the category for the node
+    CATEGORY = "O >>/deprecated >>/OpenAI >>/Advanced >>/ChatGPT"
+
+    def fun(self, openai, model, messages):
+        # Create a chat completion using the OpenAI module
+        openai = openai["openai"]
+        completion = openai.ChatCompletion.create(
+            model=model,
+            messages=messages["messages"]
+        )
+        # Get the answer from the chat completion
+        content = completion["choices"][0]["message"]["content"]
+        return (
+            {
+                "string": content,  # Return the answer as a string
+            },
+            {
+                "completion": completion,  # Return the chat completion
+            }
+        )
+
+
+# endregion Image
+# endregion advanced
+# endregion openAI
+# region StringTools
+
+
+class O_String_deprecated:
+    """
+    this node is a simple string node that can be used to hold userinput as string
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"string": ("STRING", {"multiline": True})}}
+
+    RETURN_TYPES = ("STR",)
+    FUNCTION = "ostr"
+    CATEGORY = "O >>/deprecated >>/string >>"
+
+    @staticmethod
+    def ostr(string):
+        return ({"string": string},)
+
+
+class DebugString_deprecated:
+    """
+    This node will write a string to the console
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"string": ("STR",)}}
+
+    RETURN_TYPES = ()
+    FUNCTION = "debug_string"
+    OUTPUT_NODE = True
+    CATEGORY = "O >>/deprecated >>/string >>"
+
+    @staticmethod
+    def debug_string(string):
+        print("debugString:", string["string"])
+        return ()
+
+
+class string2Image_deprecated:
+    """
+    This node will convert a string to an image
+    """
+
+    def __init__(self):
+        self.font_filepath = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "fonts")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "string": ("STR",),
+                "font": ("STRING", {"default": "CALIBRI.TTF", "multiline": False}),
+                "size": ("INT", {"default": 36, "min": 0, "max": 255, "step": 1}),
+                "font_R": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "font_G": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "font_B": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                "background_R": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_G": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                "background_B": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "create_image"
+    OUTPUT_NODE = False
+    CATEGORY = "O >>/deprecated >>/string >>"
+
+    def create_image(self, string, font, size, font_R, font_G, font_B, background_R, background_G, background_B):
+        font_color = (font_R, font_G, font_B)
+        font = ImageFont.truetype(self.font_filepath+"\\"+font, size)
+        mask_image = font.getmask(string["string"], "L")
+        image = Image.new("RGBA", mask_image.size,
+                          (background_R, background_G, background_B))
+        # need to use the inner `img.im.paste` due to `getmask` returning a core
+        image.im.paste(font_color, (0, 0) + mask_image.size, mask_image)
+
+        # Convert the  PIL Image to a tensor
+        image_np = np.array(image).astype(np.float32) / 255.0
+        image_tensor = torch.from_numpy(image_np).unsqueeze(0)
+        return (image_tensor,)
+
+
+class CLIPStringEncode_deprecated:
+    """
+    This node will encode a string with CLIP
+    """
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "string": ("STR",),
+            "clip": ("CLIP", )
+        }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "encode"
+
+    CATEGORY = "O >>/deprecated >>/string >>"
+
+    def encode(self, string, clip):
+        return ([[clip.encode(string["string"]), {}]], )
+# region String/operations
+
+
+class concat_String_deprecated:
+    """
+    This node will concatenate two strings together
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "string1": ("STR",),
+            "string2": ("STR",)
+        }}
+
+    RETURN_TYPES = ("STR",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/deprecated >>/string >>/operations >>"
+
+    @staticmethod
+    def fun(string1, string2):
+        return ({"string": string1["string"] + string2["string"]},)
+
+
+class trim_String_deprecated:
+    """
+    This node will trim a string from the left and right
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "string": ("STR",),
+        }}
+
+    RETURN_TYPES = ("STR",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/deprecated >>/string >>/operations >>"
+
+    def fun(self, string):
+        return (
+            {
+                "string": (string["string"].strip()),
+            },
+        )
+
+
+class replace_String_deprecated:
+    """
+    This node will replace a string with another string
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "string": ("STR",),
+            "old": ("STRING", {"multiline": False}),
+            "new": ("STRING", {"multiline": False})
+        }}
+
+    RETURN_TYPES = ("STR",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/deprecated >>/string >>/operations >>"
+
+    @staticmethod
+    def fun(string, old, new):
+        return ({"string": string["string"].replace(old, new)},)
+
+ # replace a string with another string
+
+
+class replace_String_advanced_deprecated:
+    """
+    This node will replace a string with another string
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "string": ("STR",),
+            "old": ("STR",),
+            "new": ("STR",),
+        }}
+
+    RETURN_TYPES = ("STR",)
+    FUNCTION = "fun"
+    CATEGORY = "O >>/deprecated >>/string >>/operations >>"
+
+    @staticmethod
+    def fun(string, old, new):
+        return ({"string": string["string"].replace(old["string"], new["string"])},)
+# endregion
+# endregion
+
+
+class LatentUpscaleMultiply_deprecated:
+    """
+    Upscale the latent code by multiplying the width and height by a factor
+    """
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "samples": ("LATENT",),
+                "upscale_method": (cls.upscale_methods,),
+                "WidthMul": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.1}),
+                "HeightMul": ("FLOAT", {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.1}),
+                "crop": (cls.crop_methods,),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "upscale"
+    CATEGORY = "O >>/deprecated >>/latent >>"
+
+    def upscale(self, samples, upscale_method, WidthMul, HeightMul, crop):
+        s = samples.copy()
+        x = samples["samples"].shape[3]
+        y = samples["samples"].shape[2]
+
+        new_x = int(x * WidthMul)
+        new_y = int(y * HeightMul)
+        print(f"upscale from ({x*8},{y*8}) to ({new_x*8},{new_y*8})")
+
+        def enforce_mul_of_64(d):
+            leftover = d % 8
+            if leftover != 0:
+                d += 8 - leftover
+            return d
+
+        s["samples"] = comfy.utils.common_upscale(
+            samples["samples"], enforce_mul_of_64(
+                new_x), enforce_mul_of_64(new_y), upscale_method, crop
+        )
+        return (s,)
+
+# endregion deprecated
+
+
+# Define the node class mappings
+NODE_CLASS_MAPPINGS = {
+    # deprecated
+    "ChatGPT _O": O_ChatGPT_deprecated,
+    "Chat_Message_fromString _O": openAi_chat_message_STR_deprecated,
+    "compine_chat_messages _O": openAi_chat_messages_Combine_deprecated,
+    "Chat_Completion _O": openAi_chat_completion_deprecated,
+    "create_image _O": openAi_Image_create_deprecated,
+    "String _O": O_String_deprecated,
+    "Debug String _O": DebugString_deprecated,
+    "concat Strings _O": concat_String_deprecated,
+    "trim String _O": trim_String_deprecated,
+    "replace String _O": replace_String_deprecated,
+    "replace String advanced _O": replace_String_advanced_deprecated,
+    "string2Image _O": string2Image_deprecated,
+    "CLIPStringEncode _O": CLIPStringEncode_deprecated,
+    "CLIPStringEncode _O": CLIPStringEncode_deprecated,
+    "LatentUpscaleMultiply": LatentUpscaleMultiply_deprecated,
+}

update/update.py

@@ -0,0 +1,77 @@
+import importlib
+from datetime import datetime
+
+def pull(pygit2,repo, remote_name='origin', branch='master'):
+    for remote in repo.remotes:
+        #print("fetching latest changes: ",remote.name)
+        if remote.name == remote_name:
+            remote.fetch()
+            remote_master_id = repo.lookup_reference('refs/remotes/origin/%s' % (branch)).target
+            merge_result, _ = repo.merge_analysis(remote_master_id)
+            # Up to date, do nothing
+            if merge_result & pygit2.GIT_MERGE_ANALYSIS_UP_TO_DATE:
+                return
+            # We can just fastforward
+            elif merge_result & pygit2.GIT_MERGE_ANALYSIS_FASTFORWARD:
+                repo.checkout_tree(repo.get(remote_master_id))
+                try:
+                    master_ref = repo.lookup_reference('refs/heads/%s' % (branch))
+                    master_ref.set_target(remote_master_id)
+                except KeyError:
+                    repo.create_branch(branch, repo.get(remote_master_id))
+                repo.head.set_target(remote_master_id)
+            elif merge_result & pygit2.GIT_MERGE_ANALYSIS_NORMAL:
+                repo.merge(remote_master_id)
+
+                if repo.index.conflicts is not None:
+                    for conflict in repo.index.conflicts:
+                        print('Conflicts found in:', conflict[0].path)
+                    raise AssertionError('Conflicts, ahhhhh!!')
+
+                user = repo.default_signature
+                tree = repo.index.write_tree()
+                commit = repo.create_commit('HEAD',
+                                            user,
+                                            user,
+                                            'Merge!',
+                                            tree,
+                                            [repo.head.target, remote_master_id])
+                # We need to do this or git CLI will think we are still merging.
+                repo.state_cleanup()
+            else:
+                raise AssertionError('Unknown merge analysis result')
+def install_pygit2():
+    # Helper function to install the pygit2 module if not already installed
+    try:
+        importlib.import_module('pygit2')
+    except ImportError:
+        import pip
+        pip.main(['install', 'pygit2'])
+def update(repoPath = "", branch_name="main" ):
+    print(f"Updating: Quality of Life Suit...")
+
+    install_pygit2()
+    import pygit2
+
+    repo = pygit2.Repository(repoPath)
+    ident = pygit2.Signature('omar92', 'omar@92')
+    try:
+        #print("stashing current changes")
+        repo.stash(ident)
+    except KeyError:
+        #print("nothing to stash")
+        pass
+    backup_branch_name = 'backup_branch_{}'.format(datetime.today().strftime('%Y-%m-%d_%H_%M_%S'))
+    #print("creating backup branch: {}".format(backup_branch_name))
+    repo.branches.local.create(backup_branch_name, repo.head.peel())
+
+    #print(f"checking out {branch_name} branch")
+    branch = repo.lookup_branch(str(branch_name))
+    ref = repo.lookup_reference(branch.name)
+    repo.checkout(ref)
+
+    #print("pulling latest changes")
+    pull(pygit2,repo, branch=branch_name)
+
+    print(f"done: Quality of Life Suit, updated successfully...")
+

update/update_QualityOfLifeSuit.bat

@@ -0,0 +1,2 @@
+python.exe .\update.py  ..
+pause

v2.1 Workflow _ load to check whats new.json

@@ -0,0 +1,3257 @@
+{
+  "last_node_id": 84,
+  "last_link_id": 78,
+  "nodes": [
+    {
+      "id": 2,
+      "type": "Equation1param _O",
+      "pos": [
+        70.26363461036739,
+        125.46773995871277
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Equation1param _O"
+      },
+      "widgets_values": [
+        6.5,
+        "x+1/3"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "Equation2params _O",
+      "pos": [
+        81.2636346103674,
+        394.4677399587126
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 35,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "x",
+          "type": "FLOAT",
+          "link": 7,
+          "widget": {
+            "name": "x",
+            "config": [
+              "FLOAT",
+              {
+                "default": 0,
+                "min": 0,
+                "max": 18446744073709552000
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Equation2params _O"
+      },
+      "widgets_values": [
+        5,
+        2.5,
+        "x+y"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "floatToInt _O",
+      "pos": [
+        551.2636346103676,
+        134.4677399587128
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 43,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "float",
+          "type": "FLOAT",
+          "link": 4,
+          "widget": {
+            "name": "float",
+            "config": [
+              "FLOAT",
+              {
+                "default": 0,
+                "min": 0,
+                "max": 18446744073709552000
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            5
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "floatToInt _O"
+      },
+      "widgets_values": [
+        0
+      ]
+    },
+    {
+      "id": 7,
+      "type": "intToFloat _O",
+      "pos": [
+        571.2636346103676,
+        322.4677399587126
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 49,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "link": 5,
+          "widget": {
+            "name": "int",
+            "config": [
+              "INT",
+              {
+                "default": 0,
+                "min": 0,
+                "max": 18446744073709552000
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "intToFloat _O"
+      },
+      "widgets_values": [
+        0
+      ]
+    },
+    {
+      "id": 3,
+      "type": "floatToText _O",
+      "pos": [
+        558.2636346103676,
+        478.4677399587126
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 57,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "float",
+          "type": "FLOAT",
+          "link": 6,
+          "widget": {
+            "name": "float",
+            "config": [
+              "FLOAT",
+              {
+                "default": 0,
+                "min": 0,
+                "max": 18446744073709552000
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "floatToText _O"
+      },
+      "widgets_values": [
+        0
+      ]
+    },
+    {
+      "id": 4,
+      "type": "Debug Text _O",
+      "pos": [
+        945.2636346103674,
+        353.4677399587126
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {
+        "collapsed": true
+      },
+      "order": 66,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 2,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Debug Text _O"
+      },
+      "widgets_values": [
+        "",
+        "debug"
+      ]
+    },
+    {
+      "id": 12,
+      "type": "Debug Text _O",
+      "pos": [
+        1053.5936369564054,
+        815.5227515553921
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {
+        "collapsed": true
+      },
+      "order": 38,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 8,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Debug Text _O"
+      },
+      "widgets_values": [
+        "",
+        "debug"
+      ]
+    },
+    {
+      "id": 14,
+      "type": "Chat_Message _O",
+      "pos": [
+        486.5936369564066,
+        1281.5227515553931
+      ],
+      "size": {
+        "0": 389.8748779296875,
+        "1": 128.49383544921875
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "OPENAI_CHAT_MESSAGES",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        }
+      ],
+      "title": "Chat_Message _O (the init message)",
+      "properties": {
+        "Node name for S&R": "Chat_Message _O"
+      },
+      "widgets_values": [
+        "user",
+        "act as prompt generator ,i will give you text and you describe an image that match that text in details, answer with one response only"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "combine_chat_messages _O",
+      "pos": [
+        965.5936369564066,
+        1282.5227515553931
+      ],
+      "size": {
+        "0": 367.79998779296875,
+        "1": 46
+      },
+      "flags": {},
+      "order": 37,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "message1",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "link": 9
+        },
+        {
+          "name": "message2",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "OPENAI_CHAT_MESSAGES",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "links": [
+            12
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "combine_chat_messages _O"
+      }
+    },
+    {
+      "id": 19,
+      "type": "Reroute",
+      "pos": [
+        1311.5936369564051,
+        1351.5227515553931
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 45,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 12,
+          "pos": [
+            37.5,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "links": [
+            14
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 11,
+      "type": "Note _O",
+      "pos": [
+        25.593636956406257,
+        1237.5227515553931
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "updates\n - no longer need to use String nodes, so this new one is using \n   normal text parameter, so it is now compatible with other comfyUI \n   nodes that receive text\n\n - support selecting the model in chat Completion node\n   so if you have access to gpt-4 you can use it\n\n//note: using ChatGPT with revAnimated or mistoonAnime checkpoints produce stunning accurate results"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 22,
+      "type": "Note _O",
+      "pos": [
+        -443.40636304359373,
+        731.5227515553921
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "Open AI package"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 13,
+      "type": "load_openAI _O",
+      "pos": [
+        462.59363695640627,
+        1093.5227515553931
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "OPENAI",
+          "type": "OPENAI",
+          "links": [
+            18
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "load_openAI _O"
+      },
+      "widgets_values": [
+        "api_key.txt"
+      ]
+    },
+    {
+      "id": 20,
+      "type": "Reroute",
+      "pos": [
+        922.5936369564066,
+        1404.5227515553931
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 52,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 14,
+          "pos": [
+            37.5,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "links": [
+            15
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 15,
+      "type": "Chat_Message _O",
+      "pos": [
+        490.5936369564066,
+        1450.5227515553931
+      ],
+      "size": {
+        "0": 389.8748779296875,
+        "1": 128.49383544921875
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "OPENAI_CHAT_MESSAGES",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "links": [
+            10
+          ],
+          "slot_index": 0
+        }
+      ],
+      "title": "Chat_Message _O (your prompt)",
+      "properties": {
+        "Node name for S&R": "Chat_Message _O"
+      },
+      "widgets_values": [
+        "user",
+        "dancng girl"
+      ]
+    },
+    {
+      "id": 24,
+      "type": "Reroute",
+      "pos": [
+        854.5936369564066,
+        1097.5227515553931
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 36,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 18,
+          "pos": [
+            45.2,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "OPENAI",
+          "type": "OPENAI",
+          "links": [
+            19,
+            23
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 27,
+      "type": "Reroute",
+      "pos": [
+        438.59363695640627,
+        1719.5227515553931
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 50,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 24,
+          "pos": [
+            45.2,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "OPENAI",
+          "type": "OPENAI",
+          "links": [
+            22
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 29,
+      "type": "Note _O",
+      "pos": [
+        29.593636956406243,
+        1675.5227515553931
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "updates\n - create image input now is text instead of string, so it can be\n   Compatible with any other text nodes \n - also add fake seeds to force the node to generate new input each \n   cycle if needed"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 28,
+      "type": "Reroute",
+      "pos": [
+        863.5936369564066,
+        1635.5227515553931
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 44,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 23,
+          "pos": [
+            45.2,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "OPENAI",
+          "type": "OPENAI",
+          "links": [
+            24,
+            28
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 30,
+      "type": "PreviewImage",
+      "pos": [
+        1056.5936369564051,
+        1782.5227515553931
+      ],
+      "size": {
+        "0": 237.004638671875,
+        "1": 215.01806640625
+      },
+      "flags": {},
+      "order": 67,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 25
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 33,
+      "type": "PreviewImage",
+      "pos": [
+        1765.5936369564051,
+        1778.5227515553931
+      ],
+      "size": {
+        "0": 237.004638671875,
+        "1": 215.01806640625
+      },
+      "flags": {},
+      "order": 73,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 30
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 32,
+      "type": "Reroute",
+      "pos": [
+        1273.5936369564051,
+        1699.5227515553931
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 51,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 28,
+          "pos": [
+            45.2,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "OPENAI",
+          "type": "OPENAI",
+          "links": [
+            29
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 8,
+      "type": "ChatGPT Simple _O",
+      "pos": [
+        498.8685881282818,
+        788.8676148366416
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            8
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ChatGPT Simple _O"
+      },
+      "widgets_values": [
+        "dancng girl",
+        "api_key.txt",
+        "gpt-3.5-turbo",
+        693269650780473,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 26,
+      "type": "create image _O",
+      "pos": [
+        521.5936369564068,
+        1782.5227515553931
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 58,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "openai",
+          "type": "OPENAI",
+          "link": 22
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            25,
+            26
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "create image _O"
+      },
+      "widgets_values": [
+        "dancng girl",
+        1,
+        "256x256",
+        0,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 17,
+      "type": "Chat completion _O",
+      "pos": [
+        972.5936369564066,
+        1475.5227515553931
+      ],
+      "size": {
+        "0": 393,
+        "1": 126
+      },
+      "flags": {},
+      "order": 59,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "openai",
+          "type": "OPENAI",
+          "link": 19
+        },
+        {
+          "name": "messages",
+          "type": "OPENAI_CHAT_MESSAGES",
+          "link": 15
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            16
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "OPENAI_CHAT_COMPLETION",
+          "type": "OPENAI_CHAT_COMPLETION",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Chat completion _O"
+      },
+      "widgets_values": [
+        "gpt-3.5-turbo",
+        0,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 35,
+      "type": "Note _O",
+      "pos": [
+        -433.40636304359373,
+        2131.522751555393
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "updates\n - remove the no longer necessary string node \n - add new NSP node\n - enhanced the text2image node\n"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 36,
+      "type": "Note _O",
+      "pos": [
+        26.593636956406257,
+        2131.522751555393
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "updates\n - this node will select a random value from the NSP file included \n   with the Package based on the terminology you select"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 39,
+      "type": "Concat Text _O",
+      "pos": [
+        989.6058622982029,
+        2515.5385796803926
+      ],
+      "size": {
+        "0": 255.0090789794922,
+        "1": 78
+      },
+      "flags": {},
+      "order": 48,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text1",
+          "type": "STRING",
+          "link": 36,
+          "widget": {
+            "name": "text1",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        },
+        {
+          "name": "text2",
+          "type": "STRING",
+          "link": 37,
+          "widget": {
+            "name": "text2",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            38
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Concat Text _O"
+      },
+      "widgets_values": [
+        "",
+        " at ",
+        ""
+      ]
+    },
+    {
+      "id": 45,
+      "type": "Debug Text _O",
+      "pos": [
+        1619.6058622982016,
+        2545.5385796803926
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {
+        "collapsed": true
+      },
+      "order": 64,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 39,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Debug Text _O"
+      },
+      "widgets_values": [
+        "",
+        "debug"
+      ]
+    },
+    {
+      "id": 43,
+      "type": "Note _O",
+      "pos": [
+        987.6058622982031,
+        2256.5385796803926
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - combine two text inputs to one text also \n   it will add the separator in the middle"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 46,
+      "type": "Note _O",
+      "pos": [
+        1297.6058622982016,
+        2255.5385796803926
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - replaces all occurrences of (old) with \n   the new) value "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 41,
+      "type": "Trim Text _O",
+      "pos": [
+        689.6058622982031,
+        2515.5385796803926
+      ],
+      "size": {
+        "0": 239.58309936523438,
+        "1": 34
+      },
+      "flags": {},
+      "order": 42,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 35,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            36
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Trim Text _O"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 47,
+      "type": "Note _O",
+      "pos": [
+        1596.6058622982016,
+        2262.5385796803926
+      ],
+      "size": {
+        "0": 210,
+        "1": 175.2283172607422
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - debug will write text to the \n   console screen"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 44,
+      "type": "Replace Text _O",
+      "pos": [
+        1279.6058622982016,
+        2515.5385796803926
+      ],
+      "size": {
+        "0": 289.0200500488281,
+        "1": 83.88400268554688
+      },
+      "flags": {},
+      "order": 56,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 38,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            39,
+            41
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Replace Text _O"
+      },
+      "widgets_values": [
+        "",
+        "Wizard",
+        "Witch"
+      ]
+    },
+    {
+      "id": 52,
+      "type": "Note _O",
+      "pos": [
+        46.593636956406215,
+        3032.522751555393
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - use text instead of String\n - allow transparent text and BG\n - allow you to set image size\n - expand: this option will resize the \n           result image to fit the text if \n           the image don't fit \n - x,y is to move the text around the image \n       it points to text center "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 51,
+      "type": "PreviewImage",
+      "pos": [
+        834.5936369564066,
+        3057.522751555393
+      ],
+      "size": {
+        "0": 1037.8057861328125,
+        "1": 210.6422882080078
+      },
+      "flags": {},
+      "order": 76,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 45
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 42,
+      "type": "Note _O",
+      "pos": [
+        670.5936369564066,
+        2256.522751555393
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - trim removes any extra spaces after or \n   before the text if found"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 50,
+      "type": "Reroute",
+      "pos": [
+        172.59363695640633,
+        2926.522751555393
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 72,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 46,
+          "pos": [
+            37.5,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "STRING",
+          "links": [
+            44
+          ]
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 49,
+      "type": "Reroute",
+      "pos": [
+        1856.5936369564051,
+        2801.522751555393
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 65,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 41,
+          "pos": [
+            37.5,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "STRING",
+          "links": [
+            46
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 53,
+      "type": "Note _O",
+      "pos": [
+        78.44912461814945,
+        4266.738520461633
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 56,
+      "type": "int _O",
+      "pos": [
+        1552.4491246181487,
+        4286.738520461633
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "int _O"
+      },
+      "widgets_values": [
+        0
+      ]
+    },
+    {
+      "id": 55,
+      "type": "seed _O",
+      "pos": [
+        1091.4491246181487,
+        4277.738520461633
+      ],
+      "size": {
+        "0": 315,
+        "1": 82
+      },
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "seed _O"
+      },
+      "widgets_values": [
+        36410646047828,
+        true
+      ]
+    },
+    {
+      "id": 54,
+      "type": "Text _O",
+      "pos": [
+        576.4491246181497,
+        4268.738520461633
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Text _O"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 58,
+      "type": "Note _O",
+      "pos": [
+        158.4491246181495,
+        4100.738520461642
+      ],
+      "size": {
+        "0": 229.99794006347656,
+        "1": 103.36981201171875
+      },
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "an empty node that can be used to write notes X) \n"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 59,
+      "type": "Note _O",
+      "pos": [
+        657.4491246181497,
+        4099.738520461642
+      ],
+      "size": {
+        "0": 229.99794006347656,
+        "1": 103.36981201171875
+      },
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "text input node"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 60,
+      "type": "Note _O",
+      "pos": [
+        1133.4491246181487,
+        4100.738520461642
+      ],
+      "size": {
+        "0": 229.99794006347656,
+        "1": 103.36981201171875
+      },
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "seed input node"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 61,
+      "type": "Note _O",
+      "pos": [
+        1596.4491246181487,
+        4101.738520461642
+      ],
+      "size": {
+        "0": 229.99794006347656,
+        "1": 103.36981201171875
+      },
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "number input nodes"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 57,
+      "type": "float _O",
+      "pos": [
+        1556.4491246181487,
+        4417.738520461633
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "float _O"
+      },
+      "widgets_values": [
+        0
+      ]
+    },
+    {
+      "id": 31,
+      "type": "variation_image _O",
+      "pos": [
+        1386.5936369564051,
+        1771.5227515553931
+      ],
+      "size": {
+        "0": 315,
+        "1": 150
+      },
+      "flags": {},
+      "order": 68,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "openai",
+          "type": "OPENAI",
+          "link": 29
+        },
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 26
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            30
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "variation_image _O"
+      },
+      "widgets_values": [
+        1,
+        "256x256",
+        0,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 9,
+      "type": "Note _O",
+      "pos": [
+        -438.375,
+        36.28409090909091
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "In this example, you can write your equation to be applied on the input "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 10,
+      "type": "Note _O",
+      "pos": [
+        27,
+        732
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "ChatGPT updates\n - support selecting the model \n   so if you have access to gpt-4 you can use it\n\n - add a seed input (it is not a real seed) but it is used to make \n   the node generate new input \n\n\n//note: using ChatGPT with revAnimated or mistoonAnime checkpoints produce stunning accurate results"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 23,
+      "type": "Note _O",
+      "pos": [
+        -428,
+        -452
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "Thanks for using my tools \n\n- kindly notice that the green colored nodes are the new updates in \n  this version"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 21,
+      "type": "Debug Text _O",
+      "pos": [
+        1460,
+        1541
+      ],
+      "size": {
+        "0": 210,
+        "1": 58
+      },
+      "flags": {
+        "collapsed": true
+      },
+      "order": 69,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 16,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Debug Text _O"
+      },
+      "widgets_values": [
+        "",
+        "debug"
+      ]
+    },
+    {
+      "id": 63,
+      "type": "ImageScaleFactor _O",
+      "pos": [
+        1433,
+        351
+      ],
+      "size": {
+        "0": 315,
+        "1": 154
+      },
+      "flags": {},
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageScaleFactor _O"
+      },
+      "widgets_values": [
+        "nearest-exact",
+        1.25,
+        1.25,
+        "enabled",
+        "disabled"
+      ]
+    },
+    {
+      "id": 67,
+      "type": "Note _O",
+      "pos": [
+        1389,
+        90
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 28,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "Upscale image using factors "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 64,
+      "type": "Note _O",
+      "pos": [
+        -325,
+        3465
+      ],
+      "size": [
+        305.0923840439583,
+        101.80222838475856
+      ],
+      "flags": {},
+      "order": 29,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "latent tools \n - new node added SelectLatentFromBatch_O\n\nit is useful if you want to select an image to continue working on after generating multiple images "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 65,
+      "type": "Note _O",
+      "pos": [
+        -288,
+        4046
+      ],
+      "size": {
+        "0": 229.99794006347656,
+        "1": 103.36981201171875
+      },
+      "flags": {},
+      "order": 30,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        "utility nodes\n\n- the input nodes good if you want to \n  reroute after them as currently the \n  primitive node dost work with \n  reroute nodes "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 69,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        38,
+        3519
+      ],
+      "size": {
+        "0": 210,
+        "1": 98
+      },
+      "flags": {},
+      "order": 31,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            47
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            53,
+            54
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            59
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "sd-v1-4.ckpt"
+      ]
+    },
+    {
+      "id": 70,
+      "type": "CLIPTextEncode",
+      "pos": [
+        43,
+        3657
+      ],
+      "size": [
+        210,
+        76.00001335144043
+      ],
+      "flags": {},
+      "order": 39,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 53
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            48
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "cute girl "
+      ]
+    },
+    {
+      "id": 71,
+      "type": "CLIPTextEncode",
+      "pos": [
+        48,
+        3770
+      ],
+      "size": {
+        "0": 210,
+        "1": 76.00001525878906
+      },
+      "flags": {},
+      "order": 40,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 54
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            49
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "bad hands "
+      ]
+    },
+    {
+      "id": 72,
+      "type": "EmptyLatentImage",
+      "pos": [
+        49,
+        3883
+      ],
+      "size": {
+        "0": 210,
+        "1": 106
+      },
+      "flags": {},
+      "order": 32,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            50
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        512,
+        512,
+        4
+      ],
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 73,
+      "type": "VAEDecode",
+      "pos": [
+        739.204545454546,
+        3541.295454545454
+      ],
+      "size": {
+        "0": 140,
+        "1": 46
+      },
+      "flags": {},
+      "order": 54,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 51
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 69
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            55
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 77,
+      "type": "Reroute",
+      "pos": [
+        254,
+        3464
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 41,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 59
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            62
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 78,
+      "type": "Reroute",
+      "pos": [
+        657.204545454546,
+        3467.295454545454
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 47,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 62
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            69,
+            78
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 74,
+      "type": "PreviewImage",
+      "pos": [
+        895,
+        3458
+      ],
+      "size": {
+        "0": 210,
+        "1": 250
+      },
+      "flags": {},
+      "order": 61,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 55
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 76,
+      "type": "PreviewImage",
+      "pos": [
+        1382,
+        3560.75
+      ],
+      "size": {
+        "0": 210,
+        "1": 250
+      },
+      "flags": {},
+      "order": 70,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 58
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 80,
+      "type": "VAEDecode",
+      "pos": [
+        1640,
+        3850
+      ],
+      "size": {
+        "0": 140,
+        "1": 46
+      },
+      "flags": {},
+      "order": 71,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 66
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 77
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            68
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 81,
+      "type": "PreviewImage",
+      "pos": [
+        1797,
+        3726
+      ],
+      "size": {
+        "0": 210,
+        "1": 250
+      },
+      "flags": {},
+      "order": 74,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 68
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 62,
+      "type": "LatentUpscaleFactor _O",
+      "pos": [
+        838,
+        3848
+      ],
+      "size": {
+        "0": 315,
+        "1": 130
+      },
+      "flags": {},
+      "order": 60,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 65
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            66
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LatentUpscaleFactor _O"
+      },
+      "widgets_values": [
+        "bilinear",
+        1.25,
+        1.25,
+        "disabled"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 68,
+      "type": "KSampler",
+      "pos": [
+        284,
+        3540
+      ],
+      "size": [
+        210,
+        430.00315768659584
+      ],
+      "flags": {},
+      "order": 46,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 47
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 48,
+          "slot_index": 1
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 49
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 50,
+          "slot_index": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            51,
+            56
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1020066313120726,
+        false,
+        20,
+        8,
+        "euler",
+        "karras",
+        1
+      ]
+    },
+    {
+      "id": 66,
+      "type": "selectLatentFromBatch _O",
+      "pos": [
+        571,
+        3721
+      ],
+      "size": {
+        "0": 210,
+        "1": 58
+      },
+      "flags": {},
+      "order": 53,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 56
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            57,
+            65
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "selectLatentFromBatch _O"
+      },
+      "widgets_values": [
+        2
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 75,
+      "type": "VAEDecode",
+      "pos": [
+        1203,
+        3721
+      ],
+      "size": {
+        "0": 140,
+        "1": 46
+      },
+      "flags": {},
+      "order": 62,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 57
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 75
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            58
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 83,
+      "type": "Reroute",
+      "pos": [
+        1129,
+        3471
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 55,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 78
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            75,
+            76
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 84,
+      "type": "Reroute",
+      "pos": [
+        1553,
+        3475
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 63,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 76
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            77
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "showOutputText": true,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 48,
+      "type": "Text2Image _O",
+      "pos": [
+        355.59363695640627,
+        2945.522751555393
+      ],
+      "size": {
+        "0": 400,
+        "1": 436.00006103515625
+      },
+      "flags": {},
+      "order": 75,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 44,
+          "widget": {
+            "name": "text",
+            "config": [
+              "STRING",
+              {
+                "multiline": true
+              }
+            ]
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            45
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Text2Image _O"
+      },
+      "widgets_values": [
+        "",
+        "CALIBRI.TTF",
+        36,
+        0,
+        0,
+        0,
+        255,
+        255,
+        255,
+        255,
+        255,
+        512,
+        256,
+        "true",
+        256,
+        128
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 34,
+      "type": "RandomNSP _O",
+      "pos": [
+        61.593636956406215,
+        2429.522751555393
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 33,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            35
+          ],
+          "slot_index": 0
+        }
+      ],
+      "title": "RandomNSP _O  (Creature)",
+      "properties": {
+        "Node name for S&R": "RandomNSP _O"
+      },
+      "widgets_values": [
+        "fantasy-creature",
+        864738385711296,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 37,
+      "type": "RandomNSP _O",
+      "pos": [
+        61.602386956406235,
+        2639.859001555393
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 34,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            37
+          ],
+          "slot_index": 0
+        }
+      ],
+      "title": "RandomNSP _O  (Location)",
+      "properties": {
+        "Node name for S&R": "RandomNSP _O"
+      },
+      "widgets_values": [
+        "pop-location",
+        837829450938436,
+        false
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    }
+  ],
+  "links": [
+    [
+      2,
+      3,
+      0,
+      4,
+      0,
+      "STRING"
+    ],
+    [
+      4,
+      5,
+      0,
+      6,
+      0,
+      "FLOAT"
+    ],
+    [
+      5,
+      6,
+      0,
+      7,
+      0,
+      "INT"
+    ],
+    [
+      6,
+      7,
+      0,
+      3,
+      0,
+      "FLOAT"
+    ],
+    [
+      7,
+      2,
+      0,
+      5,
+      0,
+      "FLOAT"
+    ],
+    [
+      8,
+      8,
+      0,
+      12,
+      0,
+      "STRING"
+    ],
+    [
+      9,
+      14,
+      0,
+      16,
+      0,
+      "OPENAI_CHAT_MESSAGES"
+    ],
+    [
+      10,
+      15,
+      0,
+      16,
+      1,
+      "OPENAI_CHAT_MESSAGES"
+    ],
+    [
+      12,
+      16,
+      0,
+      19,
+      0,
+      "*"
+    ],
+    [
+      14,
+      19,
+      0,
+      20,
+      0,
+      "*"
+    ],
+    [
+      15,
+      20,
+      0,
+      17,
+      1,
+      "OPENAI_CHAT_MESSAGES"
+    ],
+    [
+      16,
+      17,
+      0,
+      21,
+      0,
+      "STRING"
+    ],
+    [
+      18,
+      13,
+      0,
+      24,
+      0,
+      "*"
+    ],
+    [
+      19,
+      24,
+      0,
+      17,
+      0,
+      "OPENAI"
+    ],
+    [
+      22,
+      27,
+      0,
+      26,
+      0,
+      "OPENAI"
+    ],
+    [
+      23,
+      24,
+      0,
+      28,
+      0,
+      "*"
+    ],
+    [
+      24,
+      28,
+      0,
+      27,
+      0,
+      "*"
+    ],
+    [
+      25,
+      26,
+      0,
+      30,
+      0,
+      "IMAGE"
+    ],
+    [
+      26,
+      26,
+      0,
+      31,
+      1,
+      "IMAGE"
+    ],
+    [
+      28,
+      28,
+      0,
+      32,
+      0,
+      "*"
+    ],
+    [
+      29,
+      32,
+      0,
+      31,
+      0,
+      "OPENAI"
+    ],
+    [
+      30,
+      31,
+      0,
+      33,
+      0,
+      "IMAGE"
+    ],
+    [
+      35,
+      34,
+      0,
+      41,
+      0,
+      "STRING"
+    ],
+    [
+      36,
+      41,
+      0,
+      39,
+      0,
+      "STRING"
+    ],
+    [
+      37,
+      37,
+      0,
+      39,
+      1,
+      "STRING"
+    ],
+    [
+      38,
+      39,
+      0,
+      44,
+      0,
+      "STRING"
+    ],
+    [
+      39,
+      44,
+      0,
+      45,
+      0,
+      "STRING"
+    ],
+    [
+      41,
+      44,
+      0,
+      49,
+      0,
+      "*"
+    ],
+    [
+      44,
+      50,
+      0,
+      48,
+      0,
+      "STRING"
+    ],
+    [
+      45,
+      48,
+      0,
+      51,
+      0,
+      "IMAGE"
+    ],
+    [
+      46,
+      49,
+      0,
+      50,
+      0,
+      "*"
+    ],
+    [
+      47,
+      69,
+      0,
+      68,
+      0,
+      "MODEL"
+    ],
+    [
+      48,
+      70,
+      0,
+      68,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      49,
+      71,
+      0,
+      68,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      50,
+      72,
+      0,
+      68,
+      3,
+      "LATENT"
+    ],
+    [
+      51,
+      68,
+      0,
+      73,
+      0,
+      "LATENT"
+    ],
+    [
+      53,
+      69,
+      1,
+      70,
+      0,
+      "CLIP"
+    ],
+    [
+      54,
+      69,
+      1,
+      71,
+      0,
+      "CLIP"
+    ],
+    [
+      55,
+      73,
+      0,
+      74,
+      0,
+      "IMAGE"
+    ],
+    [
+      56,
+      68,
+      0,
+      66,
+      0,
+      "LATENT"
+    ],
+    [
+      57,
+      66,
+      0,
+      75,
+      0,
+      "LATENT"
+    ],
+    [
+      58,
+      75,
+      0,
+      76,
+      0,
+      "IMAGE"
+    ],
+    [
+      59,
+      69,
+      2,
+      77,
+      0,
+      "*"
+    ],
+    [
+      62,
+      77,
+      0,
+      78,
+      0,
+      "*"
+    ],
+    [
+      65,
+      66,
+      0,
+      62,
+      0,
+      "LATENT"
+    ],
+    [
+      66,
+      62,
+      0,
+      80,
+      0,
+      "LATENT"
+    ],
+    [
+      68,
+      80,
+      0,
+      81,
+      0,
+      "IMAGE"
+    ],
+    [
+      69,
+      78,
+      0,
+      73,
+      1,
+      "VAE"
+    ],
+    [
+      75,
+      83,
+      0,
+      75,
+      1,
+      "VAE"
+    ],
+    [
+      76,
+      83,
+      0,
+      84,
+      0,
+      "*"
+    ],
+    [
+      77,
+      84,
+      0,
+      80,
+      1,
+      "VAE"
+    ],
+    [
+      78,
+      78,
+      0,
+      83,
+      0,
+      "*"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Numbers",
+      "bounding": [
+        0,
+        0,
+        1129,
+        609
+      ],
+      "color": "#8A8"
+    },
+    {
+      "title": "OpenAI",
+      "bounding": [
+        3,
+        638,
+        2030,
+        1387
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "ChatGPT simple",
+      "bounding": [
+        462,
+        690,
+        1560,
+        335
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "ChatGPT",
+      "bounding": [
+        470,
+        1196,
+        1552,
+        416
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "Dalle2",
+      "bounding": [
+        473,
+        1634,
+        1550,
+        372
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "Text tools",
+      "bounding": [
+        5,
+        2042,
+        2029,
+        1359
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "Soup Prompts",
+      "bounding": [
+        32,
+        2345,
+        403,
+        422
+      ],
+      "color": "#8A8"
+    },
+    {
+      "title": "text operations",
+      "bounding": [
+        469,
+        2104,
+        1543,
+        665
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "Utility",
+      "bounding": [
+        -4,
+        4007,
+        2027,
+        606
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "Latent tools",
+      "bounding": [
+        7,
+        3416,
+        2024,
+        579
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "Image tools",
+      "bounding": [
+        1157,
+        -1,
+        872,
+        609
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "generate 4 images",
+      "bounding": [
+        6,
+        3451,
+        510,
+        543
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "Group",
+      "bounding": [
+        73,
+        3485,
+        140,
+        80
+      ],
+      "color": "#3f789e"
+    },
+    {
+      "title": "Group",
+      "bounding": [
+        53,
+        3487,
+        140,
+        80
+      ],
+      "color": "#3f789e"
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}