Upload 24 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+fonts/CALIBRI.TTF filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+Config.json
+nsp_pantry.json
+output
+

README.md

@@ -0,0 +1,82 @@
+## Thank you to all the valuable contributors. Kindly submit any pull requests to the development branch instead of the main branch. Your efforts are greatly appreciated.
+
+# 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
+- when you run comfyUI, the suit will generate a config file
+The file looks like this :
+
+{
+"autoUpdate": true,
+"branch": "main",
+"openAI_API_Key": "sk-#################################"
+}
+
+- if you want to stop autoUpdate edit  `config.json` set "autoUpdate": false
+
+## Current nodes
+## openAI suite
+
+## ChatGPT simple
+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 `config.json` file
+- I have made it a separate file, so that the API key doesn't get embedded in the generated images.
+
+## advanced openAI
+- load_openAI:load openAI module 
+### ChatGPT
+- Chat_Message: creates a message to be sent to chatGPT
+- combine_chat_messages : combine 2 messages together 
+- Chat completion: send the messages to ChatGPT and receive answer
+### DalE-2
+- create image
+- variation_image
+
+## String Suit
+This set of nodes adds support for string manipulation and includes a tool to generate an image from text.
+
+- 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 : This nodes replace part of the text with another part.
+- Debug String: This node writes the string to the console.
+- Debug String route: This node writes the string to the console but will output the same string so that you can add it in middle of a route.
+### 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.
+
+### save text
+- saveTextToFile: this node will save input text to a file "the file will be generated inside  /output folder"
+### NSP
+"node soup" which is a collection of different values categorized under different terminologies that you can use to generate new prompts easily 
+- RandomNSP: returns a random value from the selected terminology 
+- ConcatRandomNSP: will append a random value from the selected terminology to the input text (can be used mid route)
+
+## latentTools
+### selectLatentFromBatch
+this node allow you to select 1 latent image from image batch 
+for example if you generate 4 images, it allow you to select 1 of them to do further processing on it 
+or you can use it to process them sequentially 
+### LatentUpscaleFactor & LatentUpscaleFactorSimple 
+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).
+
+## ImageTools
+### ImageScaleFactor & ImageScaleFactorSimple  
+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).
+
+
+## Thanks for reading my message, and I hope that my tools will help you.
+
+## Contact
+### Discord: Omar92#3374
+### GitHub: omar92 (https://github.com/omar92)

Workflows/All nodes Workdflow .json

@@ -0,0 +1,3338 @@
+{
+  "last_node_id": 86,
+  "last_link_id": 80,
+  "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": 44,
+      "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": 51,
+      "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": 59,
+      "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": 14,
+      "type": "Chat_Message _O",
+      "pos": [
+        490.4199728939069,
+        1279.0299540944563
+      ],
+      "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": [
+        969.4199728939068,
+        1280.0299540944563
+      ],
+      "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": [
+        1315.4199728939052,
+        1349.0299540944563
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 46,
+      "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"
+      }
+    },
+    {
+      "id": 20,
+      "type": "Reroute",
+      "pos": [
+        926.4199728939068,
+        1402.0299540944563
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 54,
+      "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": [
+        494.4199728939069,
+        1448.0299540944563
+      ],
+      "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": 27,
+      "type": "Reroute",
+      "pos": [
+        436.56722430992215,
+        1721.548828508518
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 52,
+      "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": [
+        865.3935602474226,
+        1635.0560310475812
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 45,
+      "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": [
+        1054.5672243099211,
+        1784.548828508518
+      ],
+      "size": {
+        "0": 237.004638671875,
+        "1": 215.01806640625
+      },
+      "flags": {},
+      "order": 69,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 25
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 33,
+      "type": "PreviewImage",
+      "pos": [
+        1763.5672243099211,
+        1780.548828508518
+      ],
+      "size": {
+        "0": 237.004638671875,
+        "1": 215.01806640625
+      },
+      "flags": {},
+      "order": 75,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 30
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 32,
+      "type": "Reroute",
+      "pos": [
+        1271.5672243099211,
+        1701.548828508518
+      ],
+      "size": [
+        90.4,
+        26
+      ],
+      "flags": {},
+      "order": 53,
+      "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": 26,
+      "type": "create image _O",
+      "pos": [
+        519.567224309923,
+        1784.548828508518
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 60,
+      "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": [
+        976.4199728939068,
+        1473.0299540944563
+      ],
+      "size": {
+        "0": 393,
+        "1": 126
+      },
+      "flags": {},
+      "order": 61,
+      "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": 7,
+      "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": 8,
+      "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": [
+        978.2740901701846,
+        2513.6782103622136
+      ],
+      "size": {
+        "0": 255.0090789794922,
+        "1": 78
+      },
+      "flags": {},
+      "order": 49,
+      "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": 43,
+      "type": "Note _O",
+      "pos": [
+        976.2740901701849,
+        2254.6782103622136
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 9,
+      "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": [
+        1286.2740901701827,
+        2253.6782103622136
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 10,
+      "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": 44,
+      "type": "Replace Text _O",
+      "pos": [
+        1268.2740901701827,
+        2513.6782103622136
+      ],
+      "size": {
+        "0": 289.0200500488281,
+        "1": 83.88400268554688
+      },
+      "flags": {},
+      "order": 58,
+      "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": 12,
+      "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": 78,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 45
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 42,
+      "type": "Note _O",
+      "pos": [
+        659.2618648283882,
+        2254.662382237214
+      ],
+      "size": {
+        "0": 261.47479248046875,
+        "1": 202.4876708984375
+      },
+      "flags": {},
+      "order": 13,
+      "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": 74,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 46,
+          "pos": [
+            37.5,
+            0
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "STRING",
+          "links": [
+            44
+          ]
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": true
+      }
+    },
+    {
+      "id": 53,
+      "type": "Note _O",
+      "pos": [
+        78.44912461814945,
+        4266.738520461633
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 14,
+      "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": 15,
+      "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": 16,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "seed _O"
+      },
+      "widgets_values": [
+        555830498635480,
+        true
+      ]
+    },
+    {
+      "id": 54,
+      "type": "Text _O",
+      "pos": [
+        576.4491246181497,
+        4268.738520461633
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 17,
+      "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": 18,
+      "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": 19,
+      "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": 20,
+      "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": 21,
+      "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": 22,
+      "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": [
+        1384.5672243099211,
+        1773.548828508518
+      ],
+      "size": {
+        "0": 315,
+        "1": 150
+      },
+      "flags": {},
+      "order": 70,
+      "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": 23,
+      "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": 24,
+      "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": 25,
+      "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": 67,
+      "type": "Note _O",
+      "pos": [
+        1389,
+        90
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 26,
+      "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": {
+        "0": 305.0923767089844,
+        "1": 101.80223083496094
+      },
+      "flags": {},
+      "order": 27,
+      "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": 28,
+      "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": 29,
+      "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": {
+        "0": 210,
+        "1": 76.00001525878906
+      },
+      "flags": {},
+      "order": 38,
+      "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": 39,
+      "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": 30,
+      "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": 56,
+      "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": 40,
+      "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": 48,
+      "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": 63,
+      "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": 72,
+      "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": 73,
+      "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": 76,
+      "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": 62,
+      "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": {
+        "0": 210,
+        "1": 430.0031433105469
+      },
+      "flags": {},
+      "order": 47,
+      "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": 55,
+      "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": 64,
+      "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": 57,
+      "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": 65,
+      "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": 77,
+      "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": 31,
+      "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": 32,
+      "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"
+    },
+    {
+      "id": 8,
+      "type": "ChatGPT Simple _O",
+      "pos": [
+        498.8685881282818,
+        788.8676148366416
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 33,
+      "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",
+        "gpt-3.5-turbo",
+        1122472901949655,
+        693269650780473
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 4,
+      "type": "Debug Text _O",
+      "pos": [
+        912,
+        476
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 68,
+      "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": [
+        "",
+        "Numbers"
+      ]
+    },
+    {
+      "id": 85,
+      "type": "LoadImage",
+      "pos": [
+        1184,
+        341
+      ],
+      "size": [
+        218.67405007102252,
+        206.55003703724253
+      ],
+      "flags": {},
+      "order": 34,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            79
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 24,
+      "type": "Reroute",
+      "pos": [
+        853,
+        1135
+      ],
+      "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": 86,
+      "type": "PreviewImage",
+      "pos": [
+        1800,
+        331
+      ],
+      "size": {
+        "0": 210,
+        "1": 250
+      },
+      "flags": {},
+      "order": 50,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 80
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 12,
+      "type": "Debug Text _O",
+      "pos": [
+        1002,
+        796
+      ],
+      "size": [
+        280.1154894326173,
+        58
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 42,
+      "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": [
+        "",
+        "ChatGPT simple"
+      ]
+    },
+    {
+      "id": 21,
+      "type": "Debug Text _O",
+      "pos": [
+        1448,
+        1469
+      ],
+      "size": {
+        "0": 210,
+        "1": 58
+      },
+      "flags": {
+        "collapsed": false
+      },
+      "order": 71,
+      "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": [
+        "",
+        "ChatGPT"
+      ]
+    },
+    {
+      "id": 41,
+      "type": "Trim Text _O",
+      "pos": [
+        666,
+        2518
+      ],
+      "size": {
+        "0": 239.58309936523438,
+        "1": 34
+      },
+      "flags": {},
+      "order": 41,
+      "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": 45,
+      "type": "Debug Text _O",
+      "pos": [
+        1618,
+        2519
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 66,
+      "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": [
+        "",
+        "NSP"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 49,
+      "type": "Reroute",
+      "pos": [
+        1619,
+        2797
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 67,
+      "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": 47,
+      "type": "Note _O",
+      "pos": [
+        1614,
+        2255
+      ],
+      "size": {
+        "0": 210,
+        "1": 175.2283172607422
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "Note _O"
+      },
+      "widgets_values": [
+        " - debug will write text to the \n   console screen\n - prefix will be written before \n   your log  "
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 63,
+      "type": "ImageScaleFactor _O",
+      "pos": [
+        1433,
+        351
+      ],
+      "size": {
+        "0": 315,
+        "1": 154
+      },
+      "flags": {},
+      "order": 43,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 79
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            80
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageScaleFactor _O"
+      },
+      "widgets_values": [
+        "nearest-exact",
+        1.25,
+        1.25,
+        "enabled",
+        "disabled"
+      ],
+      "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,
+      "*"
+    ],
+    [
+      79,
+      85,
+      0,
+      63,
+      0,
+      "IMAGE"
+    ],
+    [
+      80,
+      63,
+      0,
+      86,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "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": [
+        474,
+        1194,
+        1552,
+        416
+      ],
+      "color": "#88A"
+    },
+    {
+      "title": "Dalle2",
+      "bounding": [
+        471,
+        1636,
+        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": [
+        458,
+        2102,
+        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
+}

__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

fonts/__init__.py

@@ -0,0 +1 @@
+## empty

src/QualityOfLifeSuit_Omar92.py

@@ -0,0 +1,1638 @@
+# 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()+'./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 = os.path.normpath(os.path.join(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
+#region chatGPTDefaultInitMessages
+chatGPTDefaultInitMessage_tags = """
+First, some basic Stable Diffusion prompting rules for you to better understand the syntax. The parentheses are there for grouping prompt words together, so that we can set uniform weight to multiple words at the same time. Notice the ":1.2" in (masterpiece, best quality, absurdres:1.2), it means that we set the weight of both "masterpiece" and "best quality" to 1.2. The parentheses can also be used to directly increase weight for single word without adding ":WEIGHT". For example, we can type ((masterpiece)), this will increase the weight of "masterpiece" to 1.21. This basic rule is imperative that any parentheses in a set of prompts have purpose, and so they must not be remove at any case. Conversely, when brackets are used in prompts, it means to decrease the weight of a word. For example, by typing "[bird]", we decrease the weight of the word "bird" by 1.1.
+Now, I've develop a prompt template to use generate character portraits in Stable Diffusion. Here's how it works. Every time user sent you "CHAR prompts", you should give prompts that follow below format:
+CHAR: [pre-defined prompts], [location], [time], [weather], [gender], [skin color], [photo type], [pose], [camera position], [facial expression], [body feature], [skin feature], [eye color], [outfit], [hair style], [hair color], [accessories], [random prompt],
+
+[pre-defined prompts] are always the same, which are "RAW, (masterpiece, best quality, photorealistic, absurdres, 8k:1.2), best lighting, complex pupils, complex textile, detailed background". Don't change anything in [pre-defined prompts], meaning that you SHOULD NOT REMOVE OR MODIFY the parentheses since their purpose is for grouping prompt words together so that we can set uniform weight to them;
+[location] is the location where character is in, can be either outdoor location or indoor, but need to be specific;
+[time] refers to the time of day, can be "day", "noon", "night", "evening", "dawn" or "dusk";
+[weather] is the weather, for example "windy", "rainy" or "cloudy";
+[gender] is either "1boy" or "1girl";
+[skin color] is the skin color of the character, could be "dark skin", "yellow skin" or "pale skin";
+[photo type] can be "upper body", "full body", "close up", "mid-range", "Headshot", "3/4 shot" or "environmental portrait";
+[pose] is the character's pose, for example, "standing", "sitting", "kneeling" or "squatting" ...;
+[camera position] can be "from top", "from below", "from side", "from front" or "from behind";
+[facial expression] is the expression of the character, you should give user a random expression;
+[body feature] describe how the character's body looks like, for example, it could be "wide hip", "large breasts" or "sexy", try to be creative;
+[skin feature] is the feature of character's skin. Could be "scar on skin", "dirty skin", "tanned mark", "birthmarks" or other skin features you can think of;
+[eye color] is the pupil color of the character, it can be of any color as long as the color looks natural on human eyes, so avoid colors like pure red or pure black;
+[outfit] is what character wears, it should include at least the top wear, bottom wear and footwear, for example, "crop top, shorts, sneakers", the style of outfit can be any, but the [character gender] should be considered;
+[hair style] is the hairstyle of the character, [character gender] should be taken into account when setting the hairstyle;
+[hair color] can be of any color, for example, "orange hair", "multi-colored hair";
+[accessories] is the accessory the character might wear, can be "chocker", "earrings", "bracelet" or other types of accessory;
+[random prompt] will test your creativity, put anything here, just remember that you can only use nouns in [random prompt], the number of [random prompt] can be between 1 to 4. For example, you could give "campfire", but you can also give "shooting star, large moon, fallen leaves". Again, be creative with this one.
+
+also use gelbooru  tags as much as you can
+if you use gelbooru  write "gTags" before it 
+Do not use markdown syntax in prompts, do not use capital letter and keep all prompt words in the same line. Respond with "prompt:" to start prompting with us.
+
+""";
+
+chatGPTDefaultInitMessage_description = """
+act as prompt generator ,i will give you text and you describe an image that match that text in details use gelbooru  tags in your description also describe the high quality of the image, answer with one response only 
+""";
+def get_init_message(isTags=False):
+    if(isTags):
+        return chatGPTDefaultInitMessage_tags
+    else:
+        return chatGPTDefaultInitMessage_description
+
+#endregion chatGPTDefaultInitMessages
+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"}),
+                "behaviour": (["tags","description"], {"default": "description"}),
+            },
+            "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,behaviour, 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
+        initMessage = "";
+        if(behaviour == "description"):
+            initMessage = get_init_message(False);
+        else:
+            initMessage = get_init_message(True);
+        # Create a chat completion using the OpenAI module
+        try:
+            completion = openai.ChatCompletion.create(
+                model=model,
+                messages=[
+                    {"role": "user", "content":initMessage},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+        except:  # sometimes it fails first time to connect to server
+            completion = openai.ChatCompletion.create(
+                model=model,
+                messages=[
+                    {"role": "user", "content": initMessage},
+                    {"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
+
+
+class O_ChatGPT_medium_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}),
+                "initMsg": ("STRING", {"multiline": True, "default": get_init_message()}),
+                "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, initMsg, 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
+        try:
+            completion = openai.ChatCompletion.create(
+                model=model,
+                messages=[
+                    {"role": "user", "content": initMsg},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+        except:  # sometimes it fails first time to connect to server
+            completion = openai.ChatCompletion.create(
+                model=model,
+                messages=[
+                    {"role": "user", "content": initMsg},
+                    {"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":get_init_message()}),
+            }
+        }
+    # 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"]
+        try:
+            completion = openai.ChatCompletion.create(
+                model=model,
+                messages=messages["messages"]
+            )
+        except:  # sometimes it fails first time to connect to server
+            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/debug/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/debug/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 LatentUpscaleFactorSimple_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,),
+                "factor": ("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, factor, crop):
+        s = samples.copy()
+        x = samples["samples"].shape[3]
+        y = samples["samples"].shape[2]
+
+        new_x = int(x * factor)
+        new_y = int(y * factor)
+
+        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 saveTextToFile_O:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": ("STRING", {"default": '', "multiline": False, "defaultBehavior": "input"}),
+                "filename": ("STRING", {"default": "log.txt", "multiline": False}),
+            },
+            "optional": {
+                "append": (["true", "false"], {"default": True})
+            }
+        }
+
+    OUTPUT_NODE = True
+    RETURN_TYPES = ()
+    FUNCTION = "fun"
+    CATEGORY = "O/text"
+
+    def fun(self, text, filename, append):
+        # append dateTime
+        current_time = time.strftime("%d/%m/%Y %H:%M:%S")  # dd/mm/YY H:M:S
+        textToSave = f'{current_time}:  \n'
+        # append text in new line
+        textToSave += f' {text}  \n\n'
+
+        self.saveTextToFile(textToSave, filename, append)
+
+        return (textToSave, )
+
+    def saveTextToFile(self, text, filename, append):
+        saveDir = os.path.join(SUIT_DIR, "output")
+        saveFile = os.path.join(saveDir, filename)
+
+        # Create directory if it does not exist
+        if not os.path.exists(saveDir):
+            os.makedirs(saveDir)
+
+        # Write to file
+        mode = "a" if append else "w"
+        try:
+            with open(saveFile, mode, encoding="utf-8") as f:
+                f.write(text)
+        except OSError as e:
+            print(f'{PACKAGE_NAME}:error writing to file {saveFile}')
+
+
+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.path.join(SUIT_DIR, "nsp_pantry.json")
+
+    if not os.path.exists(local_pantry):
+        print(f'{PACKAGE_NAME}:downloading 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}})
+
+
+class ConcatRandomNSP_O:
+    @classmethod
+    def laodCategories(s):
+        nspterminology = laodNSP()
+        terminologies = []
+        for term in nspterminology:
+            terminologies.append(term)
+
+        return (terminologies)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "text": ("STRING", {"multiline": False, "defaultBehavior": "input"}),
+            "terminology": (s.laodCategories(),),
+            "separator": ("STRING", {"multiline": False, "default": ","}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }}
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O/text/NSP"
+
+    def fun(self, text, terminology, separator, seed):
+
+        nspterminology = laodNSP()
+        # Set the seed
+        random.seed(seed)
+
+        result = random.choice(nspterminology[terminology])
+
+        return (text+separator+result+separator, {"ui": {"STRING": result}})
+# endregion text/NSP
+
+# region debug text
+
+
+class DebugText_O:
+    """
+    This node will write a text to the console
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text": ("STRING", {"multiline": False, "defaultBehavior": "input"}),
+            "prefix": ("STRING", {"default": "debug", "multiline": False}),
+        }}
+
+    RETURN_TYPES = ()
+    FUNCTION = "debug_string"
+    OUTPUT_NODE = True
+    CATEGORY = "O/debug/text"
+
+    @staticmethod
+    def debug_string(text, prefix):
+        print(f'{PACKAGE_NAME}:{prefix}:{text}')
+        return ()
+
+
+class DebugTextRoute_O:
+    """
+    This node will write a text to the console
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "text": ("STRING", {"multiline": False, "defaultBehavior": "input"}),
+            "prefix": ("STRING", {"default": "debug", "multiline": False}),
+        }}
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "debug_string"
+    CATEGORY = "O/debug/text"
+
+    @staticmethod
+    def debug_string(text, prefix):
+        print(f'{PACKAGE_NAME}:{prefix}:{text}')
+        return (text,)
+
+
+# endregion
+
+# 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, "defaultBehavior": "input"}),
+            "text2": ("STRING", {"multiline": True, "defaultBehavior": "input"}),
+            "separator": ("STRING", {"multiline": False, "default": ","}),
+        }}
+
+    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": False, "defaultBehavior": "input"}),
+        }}
+
+    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, "defaultBehavior": "input"}),
+            "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
+
+
+def upscaleImage(image, upscale_method, WidthFactor, HeightFactor, crop, MulOf46):
+    samples = image.movedim(-1, 1)
+    height = HeightFactor * samples.shape[2]
+    width = WidthFactor * 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,)
+
+
+class ImageScaleFactorSimple_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,),
+                             "Factor": ("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, Factor, crop, MulOf46):
+        return upscaleImage(image, upscale_method, Factor, Factor, crop, MulOf46)
+
+
+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):
+        return upscaleImage(image, upscale_method, WidthFactor, HeightFactor, crop, MulOf46)
+
+# 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, "defaultBehavior": "input"}),
+            "equation": ("STRING", {"multiline": True, "default": "x*1"}),
+        }
+        }
+
+    RETURN_TYPES = ("FLOAT", "int",)
+    FUNCTION = "fun"
+    CATEGORY = "O/numbers"
+
+    def fun(self, x, equation):
+        equation = equation.replace("x", "("+str(x)+")")
+        answer = solveEquation(equation)
+        return (answer, int(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, "defaultBehavior": "input"}),
+            "y": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 0xffffffffffffffff, "defaultBehavior": "input"}),
+            "equation": ("STRING", {"multiline": True, "default": "x+y"}),
+        },
+            "optional": {
+            "equation_2": ("STRING", {"multiline": True, "default": "x+y"}),
+        }
+        }
+
+    RETURN_TYPES = ("FLOAT", "INT", "FLOAT", "INT")
+    FUNCTION = "fun"
+    CATEGORY = "O/numbers"
+
+    def fun(self, x, y, equation, equation_2):
+
+        answer = 0.0
+        answer_2 = 0.0
+
+        if (equation != ""):
+            equation = equation.replace("x", "("+str(x)+")")
+            equation = equation.replace("y", "("+str(y)+")")
+            answer = solveEquation(equation)
+
+        if (equation_2 != ""):
+            equation_2 = equation_2.replace("x", "("+str(x)+")")
+            equation_2 = equation_2.replace("y", "("+str(y)+")")
+            answer_2 = solveEquation(equation_2)
+
+        return (answer, int(answer), answer_2, int(answer_2),)
+
+
+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, "defaultBehavior": "input"}),
+        }
+        }
+
+    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, "defaultBehavior": "input"}),
+        }
+        }
+
+    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, "defaultBehavior": "input"}),
+        }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fun"
+    CATEGORY = "O/numbers"
+
+    def fun(self, float):
+        return (str(float),)
+
+
+class GetImageWidthAndHeight_O:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+    toggle = ["enabled", "disabled"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"image": ("IMAGE",),
+                             }
+                }
+    RETURN_TYPES = ("INT", "INT")
+    FUNCTION = "fun"
+
+    CATEGORY = "O/numbers"
+
+    def fun(self, image):
+        samples = image.movedim(-1, 1)
+        height = samples.shape[2]
+        width = samples.shape[3]
+        return (int(width), int(height),)
+
+
+class GetLatentWidthAndHeight_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",),
+            }
+        }
+
+    RETURN_TYPES = ("INT", "INT",)
+    FUNCTION = "fun"
+    CATEGORY = "O/numbers"
+
+    def fun(self, samples):
+        w = samples["samples"].shape[3]
+        h = samples["samples"].shape[2]
+        return (int(w), int(h),)
+
+# 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,
+    "ChatGPT compact _O": O_ChatGPT_medium_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,
+    # 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,
+    "LatentUpscaleFactorSimple _O": LatentUpscaleFactorSimple_O,
+    "selectLatentFromBatch _O": SelectLatentImage_O,
+    # "VAEDecodeParallel _O": VAEDecodeParallel_O, # coming soon
+    # StringTools------------------------------------------
+    "RandomNSP _O": RandomNSP_O,
+    "ConcatRandomNSP_O": ConcatRandomNSP_O,
+    "Concat Text _O": concat_text_O,
+    "Trim Text _O": trim_text_O,
+    "Replace Text _O": replace_text_O,
+    "saveTextToFile _O": saveTextToFile_O,
+    "Text2Image _O": Text2Image_O,
+    # ImageTools------------------------------------------
+    "ImageScaleFactor _O": ImageScaleFactor_O,
+    "ImageScaleFactorSimple _O": ImageScaleFactorSimple_O,
+    # NumberTools------------------------------------------
+    "Equation1param _O": applyEquation1param_O,
+    "Equation2params _O": applyEquation2params_O,
+    "floatToInt _O": floatToInt_O,
+    "intToFloat _O": intToFloat_O,
+    "floatToText _O": floatToText_O,
+    "GetImage_(Width&Height) _O": GetImageWidthAndHeight_O,
+    "GetLatent_(Width&Height) _O": GetLatentWidthAndHeight_O,
+    # debug------------------------------------------
+    "debug messages_O": DebugOpenAIChatMEssages_O,
+    "debug Completeion _O": DebugOpenAIChatCompletion_O,
+    "Debug Text _O": DebugText_O,
+    "Debug Text route _O": DebugTextRoute_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 = './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 = './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