update: don't randomize noise_seed if it's an input from another node

This reverts commit 7552353e30.

.gitignore

@@ -1,2 +1,3 @@
 __pycache__
-.DS_Store
+.DS_Store
+file-hash-cache.json

README.md

@@ -2,6 +2,9 @@
 
 Open source comfyui deployment platform, a `vercel` for generative workflow infra. (serverless hosted gpu with vertical intergation with comfyui)
 
+> [!NOTE]  
+> Im looking for creative hacker to join ComfyDeploy's core team! DM me on [twitter](https://x.com/BennyKokMusic)
+
 Join [Discord](https://discord.gg/EEYcQmdYZw) to chat more or visit [Comfy Deploy](https://comfydeploy.com/) to get started!
 
 Check out our latest [nextjs starter kit](https://github.com/BennyKok/comfyui-deploy-next-example) with Comfy Deploy

comfy-nodes/external_audio.py

@@ -0,0 +1,57 @@
+import os
+import io
+import torchaudio
+from folder_paths import get_annotated_filepath
+
+class ComfyUIDeployExternalAudio:
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("audio",)
+    FUNCTION = "load_audio"
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_audio"},
+                ),
+                "audio_file": ("STRING", {"default": ""}),
+            },
+            "optional": {
+                "default_value": ("AUDIO",),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+            }
+        }
+    
+    @classmethod
+    def VALIDATE_INPUTS(s, audio_file, **kwargs):
+        return True
+
+    def load_audio(self, input_id, audio_file, default_value=None, display_name=None, description=None):
+        if audio_file and audio_file != "":
+            if audio_file.startswith(('http://', 'https://')):
+                # Handle URL input
+                import requests
+                response = requests.get(audio_file)
+                audio_data = io.BytesIO(response.content)
+                waveform, sample_rate = torchaudio.load(audio_data)
+            else:
+                # Handle local file
+                audio_path = get_annotated_filepath(audio_file)
+                waveform, sample_rate = torchaudio.load(audio_path)
+            
+            audio = {"waveform": waveform.unsqueeze(0), "sample_rate": sample_rate}
+            return (audio,)
+        else:
+            return (default_value,)
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalAudio": ComfyUIDeployExternalAudio}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalAudio": "External Audio (ComfyUI Deploy)"}

comfy-nodes/external_exr.py

@@ -0,0 +1,109 @@
+import os
+import io
+import cv2 as cv
+import numpy as np
+import torch
+import requests
+from folder_paths import get_annotated_filepath
+
+class ComfyUIDeployExternalEXR:
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("image", "mask") 
+    FUNCTION = "load_exr"
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_exr"},
+                ),
+                "exr_file": ("STRING", {"default": ""}),
+                "tonemap": (["linear", "sRGB", "Reinhard"], {"default": "sRGB"}),
+            },
+            "optional": {
+                "default_image": ("IMAGE",),
+                "default_mask": ("MASK",),
+                "display_name": (
+                    "STRING", 
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+            }
+        }
+
+    @classmethod
+    def VALIDATE_INPUTS(s, exr_file, **kwargs):
+        return True
+
+    def sRGBtoLinear(self, npArray):
+        less = npArray <= 0.0404482362771082
+        npArray[less] = npArray[less] / 12.92
+        npArray[~less] = np.power((npArray[~less] + 0.055) / 1.055, 2.4)
+
+    def linearToSRGB(self, npArray):
+        less = npArray <= 0.0031308
+        npArray[less] = npArray[less] * 12.92
+        npArray[~less] = np.power(npArray[~less], 1/2.4) * 1.055 - 0.055
+
+    def load_exr(self, input_id, exr_file, tonemap="sRGB", 
+                 default_image=None, default_mask=None,
+                 display_name=None, description=None):
+        try:
+            if exr_file and exr_file != "":
+                if exr_file.startswith(('http://', 'https://')):
+                    # Handle URL input
+                    response = requests.get(exr_file)
+                    # Write to temp buffer
+                    buffer = io.BytesIO(response.content)
+                    nparr = np.frombuffer(buffer.getvalue(), np.uint8)
+                    image = cv.imdecode(nparr, cv.IMREAD_UNCHANGED).astype(np.float32)
+                else:
+                    # Handle local file
+                    exr_path = get_annotated_filepath(exr_file)
+                    image = cv.imread(exr_path, cv.IMREAD_UNCHANGED).astype(np.float32)
+
+                if len(image.shape) == 2:
+                    image = np.repeat(image[..., np.newaxis], 3, axis=2)
+                
+                # Extract RGB and flip channels
+                rgb = np.flip(image[:,:,:3], 2).copy()
+                
+                # Apply tonemapping
+                if tonemap == "sRGB":
+                    self.linearToSRGB(rgb)
+                    rgb = np.clip(rgb, 0, 1)
+                elif tonemap == "Reinhard":
+                    rgb = np.clip(rgb, 0, None)
+                    rgb = rgb / (rgb + 1)
+                    self.linearToSRGB(rgb)
+                    rgb = np.clip(rgb, 0, 1)
+                
+                rgb = torch.unsqueeze(torch.from_numpy(rgb), 0)
+                
+                # Handle alpha/mask
+                mask = torch.zeros((1, image.shape[0], image.shape[1]), dtype=torch.float32)
+                if image.shape[2] > 3:
+                    mask[0] = torch.from_numpy(np.clip(image[:,:,3], 0, 1))
+
+                return (rgb, mask)
+            else:
+                # Return defaults if no file provided
+                return (default_image, default_mask)
+
+        except Exception as e:
+            print(f"Error loading EXR: {str(e)}")
+            # Return defaults on error
+            return (default_image, default_mask)
+
+NODE_CLASS_MAPPINGS = {
+    "ComfyUIDeployExternalEXR": ComfyUIDeployExternalEXR
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalEXR": "External EXR (ComfyUI Deploy)"
+}

comfy-nodes/external_face_model.py

@@ -0,0 +1,108 @@
+from PIL import Image, ImageOps
+import numpy as np
+import torch
+import folder_paths
+
+
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+
+class ComfyUIDeployExternalFaceModel:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_reactor_face_model"},
+                ),
+            },
+            "optional": {
+                "default_face_model_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "face_model_save_name": (  # if `default_face_model_name` is a link to download a file, we will attempt to save it with this name
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "face_model_url": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+            },
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("path",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "deploy"
+
+    def run(
+        self,
+        input_id,
+        default_face_model_name=None,
+        face_model_save_name=None,
+        display_name=None,
+        description=None,
+        face_model_url=None,
+    ):
+        import requests
+        import os
+        import uuid
+
+        if face_model_url and face_model_url.startswith("http"):
+            if face_model_save_name:
+                existing_face_models = folder_paths.get_filename_list("reactor/faces")
+                # Check if face_model_save_name exists in the list
+                if face_model_save_name in existing_face_models:
+                    print(f"using face model: {face_model_save_name}")
+                    return (face_model_save_name,)
+            else:
+                face_model_save_name = str(uuid.uuid4()) + ".safetensors"
+            print(face_model_save_name)
+            print(folder_paths.folder_names_and_paths["reactor/faces"][0][0])
+            destination_path = os.path.join(
+                folder_paths.folder_names_and_paths["reactor/faces"][0][0],
+                face_model_save_name,
+            )
+
+            print(destination_path)
+            print(
+                "Downloading external face model - "
+                + face_model_url
+                + " to "
+                + destination_path
+            )
+            response = requests.get(
+                face_model_url,
+                headers={"User-Agent": "Mozilla/5.0"},
+                allow_redirects=True,
+            )
+            with open(destination_path, "wb") as out_file:
+                out_file.write(response.content)
+            return (face_model_save_name,)
+        else:
+            print(f"using face model: {default_face_model_name}")
+            return (default_face_model_name,)
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalFaceModel": ComfyUIDeployExternalFaceModel}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalFaceModel": "External Face Model (ComfyUI Deploy)"
+}

comfy-nodes/external_image.py

@@ -21,8 +21,9 @@ class ComfyUIDeployExternalImage:
                 ),
                 "description": (
                     "STRING",
-                    {"multiline": True, "default": ""},
+                    {"multiline": False, "default": ""},
                 ),
+                "default_value_url": ("STRING", {"image_preview": True, "default": ""}),
             }
         }
 
@@ -33,32 +34,44 @@ class ComfyUIDeployExternalImage:
 
     CATEGORY = "image"
 
-    def run(self, input_id, default_value=None, display_name=None, description=None):
+    def run(self, input_id, default_value=None, display_name=None, description=None, default_value_url=None):
         image = default_value
-        try:
-            if input_id.startswith('http'):
-                import requests
-                from io import BytesIO
-                print("Fetching image from url: ", input_id)
-                response = requests.get(input_id)
-                image = Image.open(BytesIO(response.content))
-            elif input_id.startswith('data:image/png;base64,') or input_id.startswith('data:image/jpeg;base64,') or input_id.startswith('data:image/jpg;base64,'):
-                import base64
-                from io import BytesIO
-                print("Decoding base64 image")
-                base64_image = input_id[input_id.find(",")+1:]
-                decoded_image = base64.b64decode(base64_image)
-                image = Image.open(BytesIO(decoded_image))
-            else:
-                raise ValueError("Invalid image url provided.")
-
-            image = ImageOps.exif_transpose(image)
-            image = image.convert("RGB")
-            image = np.array(image).astype(np.float32) / 255.0
-            image = torch.from_numpy(image)[None,]
-            return [image]
-        except:
-            return [image]
+        
+        # Try both input_id and default_value_url
+        urls_to_try = [url for url in [input_id, default_value_url] if url]
+        
+        print(default_value_url)
+        
+        for url in urls_to_try:
+            try:
+                if url.startswith('http'):
+                    import requests
+                    from io import BytesIO
+                    print(f"Fetching image from url: {url}")
+                    response = requests.get(url)
+                    image = Image.open(BytesIO(response.content))
+                    break
+                elif url.startswith(('data:image/png;base64,', 'data:image/jpeg;base64,', 'data:image/jpg;base64,')):
+                    import base64
+                    from io import BytesIO
+                    print("Decoding base64 image")
+                    base64_image = url[url.find(",")+1:]
+                    decoded_image = base64.b64decode(base64_image)
+                    image = Image.open(BytesIO(decoded_image))
+                    break
+            except:
+                continue
+        
+        if image is not None:
+            try:
+                image = ImageOps.exif_transpose(image)
+                image = image.convert("RGB")
+                image = np.array(image).astype(np.float32) / 255.0
+                image = torch.from_numpy(image)[None,]
+            except:
+                pass
+                
+        return [image]
 
 
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalImage": ComfyUIDeployExternalImage}

comfy-nodes/external_image_batch.py

@@ -39,14 +39,34 @@ class ComfyUIDeployExternalImageBatch:
 
     CATEGORY = "image"
     
+    def process_image(self, image):
+        image = ImageOps.exif_transpose(image)
+        image = image.convert("RGB")
+        image = np.array(image).astype(np.float32) / 255.0
+        image_tensor = torch.from_numpy(image)[None,]
+        return image_tensor
+    
     def run(self, input_id, images=None, default_value=None, display_name=None, description=None):
+        import requests
+        import zipfile
+        import io
+        
         processed_images = []
         try:
             images_list = json.loads(images)  # Assuming images is a JSON array string
             print(images_list)
             for img_input in images_list:
-                if img_input.startswith('http'):
-                    import requests
+                if img_input.startswith('http') and img_input.endswith('.zip'):
+                    print("Fetching zip file from url: ", img_input)
+                    response = requests.get(img_input)
+                    zip_file = zipfile.ZipFile(io.BytesIO(response.content))
+                    for file_name in zip_file.namelist():
+                        if file_name.lower().endswith(('.png', '.jpg', '.jpeg')):
+                            with zip_file.open(file_name) as file:
+                                image = Image.open(file)
+                                image = self.process_image(image)
+                                processed_images.append(image)
+                elif  img_input.startswith('http'):
                     from io import BytesIO
                     print("Fetching image from url: ", img_input)
                     response = requests.get(img_input)

comfy-nodes/external_lora.py

@@ -64,32 +64,42 @@ class ComfyUIDeployExternalLora:
         import os
         import uuid
 
-        if lora_url and lora_url.startswith("http"):
-            if lora_save_name:
-                existing_loras = folder_paths.get_filename_list("loras")
-                # Check if lora_save_name exists in the list
-                if lora_save_name in existing_loras:
-                    print(f"using lora: {lora_save_name}")
-                    return (lora_save_name,)
+        if lora_url:
+            if lora_url.startswith("http"):
+                if lora_save_name:
+                    existing_loras = folder_paths.get_filename_list("loras")
+                    # Check if lora_save_name exists in the list
+                    if lora_save_name in existing_loras:
+                        print(f"using lora: {lora_save_name}")
+                        return (lora_save_name,)
+                else:
+                    lora_save_name = str(uuid.uuid4()) + ".safetensors"
+                print(lora_save_name)
+                print(folder_paths.folder_names_and_paths["loras"][0][0])
+                destination_path = os.path.join(
+                    folder_paths.folder_names_and_paths["loras"][0][0], lora_save_name
+                )
+                print(destination_path)
+                print(
+                    "Downloading external lora - "
+                    + lora_url
+                    + " to "
+                    + destination_path
+                )
+                response = requests.get(
+                    lora_url,
+                    headers={"User-Agent": "Mozilla/5.0"},
+                    allow_redirects=True,
+                )
+                with open(destination_path, "wb") as out_file:
+                    out_file.write(response.content)
+                print(f"Ext Lora loading: {lora_url} to {lora_save_name}")
+                return (lora_save_name,)
             else:
-                lora_save_name = str(uuid.uuid4()) + ".safetensors"
-            print(lora_save_name)
-            print(folder_paths.folder_names_and_paths["loras"][0][0])
-            destination_path = os.path.join(
-                folder_paths.folder_names_and_paths["loras"][0][0], lora_save_name
-            )
-            print(destination_path)
-            print("Downloading external lora - " + lora_url + " to " + destination_path)
-            response = requests.get(
-                lora_url,
-                headers={"User-Agent": "Mozilla/5.0"},
-                allow_redirects=True,
-            )
-            with open(destination_path, "wb") as out_file:
-                out_file.write(response.content)
-            return (lora_save_name,)
+                print(f"Ext Lora loading: {lora_url}")
+                return (lora_url,)
         else:
-            print(f"using lora: {default_lora_name}")
+            print(f"Ext Lora loading: {default_lora_name}")
             return (default_lora_name,)
 
 

comfy-nodes/external_string_combine.py

@@ -0,0 +1,53 @@
+import re
+
+
+class StringFunction:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "action": (["append", "replace"], {}),
+                "tidy_tags": (["yes", "no"], {}),
+            },
+            "optional": {
+                "text_a": ("STRING", {"multiline": True, "dynamicPrompts": False}),
+                "text_b": ("STRING", {"multiline": True, "dynamicPrompts": False}),
+                "text_c": ("STRING", {"multiline": True, "dynamicPrompts": False}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "exec"
+    CATEGORY = "utils"
+    OUTPUT_NODE = True
+
+    def exec(self, action, tidy_tags, text_a="", text_b="", text_c=""):
+        tidy_tags = tidy_tags == "yes"
+        out = ""
+        if action == "append":
+            out = (", " if tidy_tags else "").join(
+                filter(None, [text_a, text_b, text_c])
+            )
+        else:
+            if text_c is None:
+                text_c = ""
+            if text_b.startswith("/") and text_b.endswith("/"):
+                regex = text_b[1:-1]
+                out = re.sub(regex, text_c, text_a)
+            else:
+                out = text_a.replace(text_b, text_c)
+        if tidy_tags:
+            out = re.sub(r"\s{2,}", " ", out)
+            out = out.replace(" ,", ",")
+            out = re.sub(r",{2,}", ",", out)
+            out = out.strip()
+        return {"ui": {"text": (out,)}, "result": (out,)}
+
+
+NODE_CLASS_MAPPINGS = {
+    "ComfyUIDeployStringCombine": StringFunction,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployStringCombine": "String Combine (ComfyUI Deploy)",
+}

comfy-nodes/external_text_any.py

@@ -0,0 +1,46 @@
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+
+WILDCARD = AnyType("*")
+
+class ComfyUIDeployExternalTextAny:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_text"},
+                ),
+            },
+            "optional": {
+                "default_value": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {"multiline": True, "default": ""},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "text"
+
+    def run(self, input_id, default_value=None, display_name=None, description=None):
+        return [default_value]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalTextAny": ComfyUIDeployExternalTextAny}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalTextAny": "External Text Any (ComfyUI Deploy)"}

comfy-nodes/external_text_list.py

@@ -1,52 +0,0 @@
-import folder_paths
-from PIL import Image, ImageOps
-import numpy as np
-import torch
-import json
-
-class ComfyUIDeployExternalTextList:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "input_id": (
-                    "STRING",
-                    {"multiline": False, "default": 'input_text_list'},
-                ),
-                 "text": (
-                    "STRING",
-                    {"multiline": True, "default": "[]"},
-                ),
-            },
-            "optional": {
-                "display_name": (
-                    "STRING",
-                    {"multiline": False, "default": ""},
-                ),
-                "description": (
-                    "STRING",
-                    {"multiline": True, "default": ""},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("text",)
-
-    OUTPUT_IS_LIST = (True,)
-
-    FUNCTION = "run"
-
-    CATEGORY = "text"
-
-    def run(self, input_id, text=None, display_name=None, description=None):
-        text_list = []
-        try:
-            text_list = json.loads(text)  # Assuming text is a JSON array string
-        except Exception as e:
-            print(f"Error processing images: {e}")
-            pass
-        return ([text_list],)
-
-NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalTextList": ComfyUIDeployExternalTextList}
-NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalTextList": "External Text List (ComfyUI Deploy)"}

comfy-nodes/model_list.py

@@ -0,0 +1,60 @@
+import folder_paths
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+from os import walk
+
+WILDCARD = AnyType("*")
+
+MODEL_EXTENSIONS = {
+    "safetensors": "SafeTensors file format",
+    "ckpt": "Checkpoint file",
+    "pth": "PyTorch serialized file",
+    "pkl": "Pickle file",
+    "onnx": "ONNX file",
+}
+
+def fetch_files(path):
+    for (dirpath, dirnames, filenames) in walk(path):
+        fs = []
+        if len(dirnames) > 0:
+            for dirname in dirnames:
+                fs.extend(fetch_files(f"{dirpath}/{dirname}"))
+        for filename in filenames:
+            # Remove "./models/" from the beginning of dirpath
+            relative_dirpath = dirpath.replace("./models/", "", 1)
+            file_path = f"{relative_dirpath}/{filename}"
+            
+            # Only add files that are known model extensions
+            file_extension = filename.split('.')[-1].lower()
+            if file_extension in MODEL_EXTENSIONS:
+                fs.append(file_path)
+
+        return fs
+allModels = fetch_files("./models")
+
+class ComfyUIDeployModalList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (allModels, ),
+            }
+        }
+
+    RETURN_TYPES = (WILDCARD,)
+    RETURN_NAMES = ("model",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "model"
+
+    def run(self, model=""):
+        # Split the model path by '/' and select the last item
+        model_name = model.split('/')[-1]
+        return [model_name]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployModelList": ComfyUIDeployModalList}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployModelList": "Model List (ComfyUI Deploy)"}

comfy-nodes/output_image.py

@@ -0,0 +1,100 @@
+import os
+import json
+import numpy as np
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+import folder_paths
+
+
+class ComfyDeployOutputImage:
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+        self.prefix_append = ""
+        self.compress_level = 4
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images": ("IMAGE", {"tooltip": "The images to save."}),
+                "filename_prefix": (
+                    "STRING",
+                    {
+                        "default": "ComfyUI",
+                        "tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes.",
+                    },
+                ),
+                "file_type": (["png", "jpg", "webp"], {"default": "webp"}),
+                "quality": ("INT", {"default": 80, "min": 1, "max": 100, "step": 1}),
+                "output_id": (
+                    "STRING",
+                    {"multiline": False, "default": "output_images"},
+                ),
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "run"
+
+    OUTPUT_NODE = True
+
+    CATEGORY = "output"
+    DESCRIPTION = "Saves the input images to your ComfyUI output directory."
+
+    def run(
+        self,
+        images,
+        filename_prefix="ComfyUI",
+        file_type="png",
+        quality=80,
+        output_id="output_images",
+        prompt=None,
+        extra_pnginfo=None,
+    ):
+        filename_prefix += self.prefix_append
+        full_output_folder, filename, counter, subfolder, filename_prefix = (
+            folder_paths.get_save_image_path(
+                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
+            )
+        )
+        results = list()
+        for batch_number, image in enumerate(images):
+            i = 255.0 * image.cpu().numpy()
+            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+            metadata = PngInfo()
+            if prompt is not None:
+                metadata.add_text("prompt", json.dumps(prompt))
+            if extra_pnginfo is not None:
+                for x in extra_pnginfo:
+                    metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+
+            filename_with_batch_num = filename.replace("%batch_num%", str(batch_number))
+            file = f"{filename_with_batch_num}_{counter:05}_.{file_type}"
+            file_path = os.path.join(full_output_folder, file)
+
+            if file_type == "png":
+                img.save(
+                    file_path, pnginfo=metadata, compress_level=self.compress_level
+                )
+            elif file_type == "jpg":
+                img.save(file_path, quality=quality, optimize=True)
+            elif file_type == "webp":
+                img.save(file_path, quality=quality)
+
+            results.append(
+                {
+                    "filename": file,
+                    "subfolder": subfolder,
+                    "type": self.type,
+                    "output_id": output_id,
+                }
+            )
+            counter += 1
+
+        return {"ui": {"images": results}}
+
+
+NODE_CLASS_MAPPINGS = {"ComfyDeployOutputImage": ComfyDeployOutputImage}
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyDeployOutputImage": "Image Output (ComfyDeploy)"}

globals.py

@@ -6,10 +6,12 @@ from PIL import Image, ImageOps
 from io import BytesIO
 from pydantic import BaseModel as PydanticBaseModel
 
+
 class BaseModel(PydanticBaseModel):
     class Config:
         arbitrary_types_allowed = True
-        
+
+
 class Status(Enum):
     NOT_STARTED = "not-started"
     RUNNING = "running"
@@ -17,6 +19,7 @@ class Status(Enum):
     FAILED = "failed"
     UPLOADING = "uploading"
 
+
 class StreamingPrompt(BaseModel):
     workflow_api: Any
     auth_token: str
@@ -24,42 +27,52 @@ class StreamingPrompt(BaseModel):
     running_prompt_ids: set[str] = set()
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+    workflow: Any
+    gpu_event_id: Optional[str] = None
+
+
 class SimplePrompt(BaseModel):
     status_endpoint: Optional[str]
     file_upload_endpoint: Optional[str]
-    
+
+    token: Optional[str]
+
     workflow_api: dict
     status: Status = Status.NOT_STARTED
     progress: set = set()
-    last_updated_node: Optional[str] = None,
+    last_updated_node: Optional[str] = None
     uploading_nodes: set = set()
     done: bool = False
-    is_realtime: bool = False,
-    start_time: Optional[float] = None,
+    is_realtime: bool = False
+    start_time: Optional[float] = None
+    gpu_event_id: Optional[str] = None
+
 
 sockets = dict()
 prompt_metadata: dict[str, SimplePrompt] = {}
 streaming_prompt_metadata: dict[str, StreamingPrompt] = {}
 
+
 class BinaryEventTypes:
     PREVIEW_IMAGE = 1
     UNENCODED_PREVIEW_IMAGE = 2
-    
+
+
 max_output_id_length = 24
 
-async def send_image(image_data, sid=None, output_id:str = None):
+
+async def send_image(image_data, sid=None, output_id: str = None):
     max_length = max_output_id_length
     output_id = output_id[:max_length]
-    padded_output_id = output_id.ljust(max_length, '\x00')
-    encoded_output_id = padded_output_id.encode('ascii', 'replace')
-    
+    padded_output_id = output_id.ljust(max_length, "\x00")
+    encoded_output_id = padded_output_id.encode("ascii", "replace")
+
     image_type = image_data[0]
     image = image_data[1]
     max_size = image_data[2]
     quality = image_data[3]
     if max_size is not None:
-        if hasattr(Image, 'Resampling'):
+        if hasattr(Image, "Resampling"):
             resampling = Image.Resampling.BILINEAR
         else:
             resampling = Image.ANTIALIAS
@@ -83,17 +96,23 @@ async def send_image(image_data, sid=None, output_id:str = None):
     position_after = bytesIO.tell()
     bytes_written = position_after - position_before
     print(f"Bytes written: {bytes_written}")
-    
+
     image.save(bytesIO, format=image_type, quality=quality, compress_level=1)
     preview_bytes = bytesIO.getvalue()
     await send_bytes(BinaryEventTypes.PREVIEW_IMAGE, preview_bytes, sid=sid)
-        
+
+
 async def send_socket_catch_exception(function, message):
     try:
         await function(message)
-    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError) as err:
+    except (
+        aiohttp.ClientError,
+        aiohttp.ClientPayloadError,
+        ConnectionResetError,
+    ) as err:
         print("send error:", err)
 
+
 def encode_bytes(event, data):
     if not isinstance(event, int):
         raise RuntimeError(f"Binary event types must be integers, got {event}")
@@ -103,9 +122,10 @@ def encode_bytes(event, data):
     message.extend(data)
     return message
 
+
 async def send_bytes(event, data, sid=None):
     message = encode_bytes(event, data)
-    
+
     print("sending image to ", event, sid)
 
     if sid is None:
@@ -113,4 +133,4 @@ async def send_bytes(event, data, sid=None):
         for ws in _sockets:
             await send_socket_catch_exception(ws.send_bytes, message)
     elif sid in sockets:
-        await send_socket_catch_exception(sockets[sid].send_bytes, message)
+        await send_socket_catch_exception(sockets[sid].send_bytes, message)

pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "comfyui-deploy"
 description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
-version = "1.0.0"
-license = "LICENSE"
+version = "1.1.0"
+license = { file = "LICENSE" }
 dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg"]
 
 [project.urls]

requirements.txt

@@ -3,4 +3,5 @@ pydantic
 opencv-python
 imageio-ffmpeg
 brotli
+tabulate
 # logfire

web-plugin/api.js

@@ -1,4 +0,0 @@
-/** @typedef {import('../../../web/scripts/api.js').api} API*/
-import { api as _api } from '../../scripts/api.js';
-/** @type {API} */
-export const api = _api;

web-plugin/app.js

@@ -1,4 +0,0 @@
-/** @typedef {import('../../../web/scripts/app.js').ComfyApp} ComfyApp*/
-import { app as _app } from '../../scripts/app.js';
-/** @type {ComfyApp} */
-export const app = _app;

web-plugin/widgets.js

@@ -1,18 +0,0 @@
-// /** @typedef {import('../../../web/scripts/api.js').api} API*/
-// import { api as _api } from "../../scripts/api.js";
-// /** @type {API} */
-// export const api = _api;
-
-/** @typedef {typeof import('../../../web/scripts/widgets.js').ComfyWidgets} Widgets*/
-import { ComfyWidgets as _ComfyWidgets } from "../../scripts/widgets.js";
-
-/**
- * @type {Widgets}
- */
-export const ComfyWidgets = _ComfyWidgets;
-
-// import { LGraphNode as _LGraphNode } from "../../types/litegraph.js";
-
-/** @typedef {typeof import('../../../web/types/litegraph.js').LGraphNode} LGraphNode*/
-/** @type {LGraphNode}*/
-export const LGraphNode = LiteGraph.LGraphNode;

web/src/components/customInputNodes.tsx

@@ -6,4 +6,5 @@ export const customInputNodes: Record<string, string> = {
   ComfyUIDeployExternalNumberInt: "integer",
   ComfyUIDeployExternalLora: "string - (public lora download url)",
   ComfyUIDeployExternalCheckpoint: "string - (public checkpoints download url)",
+  ComfyUIDeployExternalFaceModel: "string - (public face model download url)",
 };