fix: lora

2024-04-24 17:00:16 -07:00
11 changed files with 57 additions and 903 deletions
@@ -1,21 +0,0 @@
 name: Publish to Comfy registry
 on:
  workflow_dispatch:
  push:
    branches:
      - main
    paths:
      - "pyproject.toml"
 jobs:
  publish-node:
    name: Publish Custom Node to registry
    runs-on: ubuntu-latest
    steps:
      - name: Check out code
        uses: actions/checkout@v4
      - name: Publish Custom Node
        uses: Comfy-Org/publish-node-action@main
        with:
          ## Add your own personal access token to your Github Repository secrets and reference it here.
          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
@@ -1,25 +0,0 @@
 class ComfyUIDeployExternalBoolean:
    @classmethod    
    def INPUT_TYPES(s):
        return {
            "required": {
                "input_id": (
                    "STRING",
                    {"multiline": False, "default": "input_bool"},
                ),
                "default_value": ("BOOLEAN", {"default": False})
            }
        }
    RETURN_TYPES = ("BOOLEAN",)
    RETURN_NAMES = ("bool_value",)
    FUNCTION = "run"
    def run(self, input_id, default_value=None):
        print(f"Node '{input_id}' processing with switch set to {default_value}")
        return [default_value]
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalBoolean": ComfyUIDeployExternalBoolean}
 NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalBoolean": "External Boolean (ComfyUI Deploy)"}
@@ -16,8 +16,8 @@ class ComfyUIDeployExternalLora:
                ),
            },
            "optional": {
-                "default_lora_name": (folder_paths.get_filename_list("loras"),),
+                "default_lora_name": (folder_paths.get_filename_list("loras"), ),
-            },
+            }
        }
    RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
@@ -32,29 +32,27 @@ class ComfyUIDeployExternalLora:
        import os
        import uuid
-        if default_lora_name.startswith("http"):
+        print('external lora using')
-            unique_filename = str(uuid.uuid4()) + ".safetensors"
+        print("input id: ", input_id)
-            print(unique_filename)
+        print("default lora : ", default_lora_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], unique_filename
            )
            print(destination_path)
            print("Downloading external lora - " + input_id + " to " + destination_path)
            response = requests.get(
                input_id,
                headers={"User-Agent": "Mozilla/5.0"},
                allow_redirects=True,
            )
            with open(destination_path, "wb") as out_file:
                out_file.write(response.content)
            return (unique_filename,)
        else:
            print(f"using lora: {default_lora_name}")
            return (default_lora_name,)
        if input_id:
            if input_id.startswith('http'):
                unique_filename = str(uuid.uuid4()) + ".safetensors"
                print(unique_filename)
                print(folder_paths.folder_names_and_paths["loras"][0][0])
                destination_path = os.path.join(folder_paths.folder_names_and_paths["loras"][0][0], unique_filename)
                print(destination_path)
                print("Downloading external lora - " + input_id + " to " + destination_path)
                response = requests.get(input_id, headers={'User-Agent': 'Mozilla/5.0'}, allow_redirects=True)
                with open(destination_path, 'wb') as out_file:
                    out_file.write(response.content)
                return (unique_filename,)
            else:
                return (input_id,)
        return (default_lora_name,)
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalLora": ComfyUIDeployExternalLora}
-NODE_DISPLAY_NAME_MAPPINGS = {
+NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"}
    "ComfyUIDeployExternalLora": "External Lora (ComfyUI Deploy)"
 }
@@ -29,7 +29,7 @@ class ComfyUIDeployExternalNumberInt:
    CATEGORY = "number"
    def run(self, input_id, default_value=None):
-        if not input_id or (isinstance(input_id, str) and not input_id.strip().isdigit()):
+        if not input_id or not input_id.strip().isdigit():
            return [default_value]
        return [int(input_id)]
@@ -1,48 +0,0 @@
 class ComfyUIDeployExternalNumberSlider:
    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "input_id": (
                    "STRING",
                    {"multiline": False, "default": "input_number_slider"},
                ),
            },
            "optional": {
                "default_value": (
                    "FLOAT",
                    {"multiline": True, "display": "number", "default": 0.5, "step": 0.01},
                ),
                "min_value": (
                    "FLOAT",
                    {"multiline": True, "display": "number", "default": 0, "step": 0.01},
                ),
                "max_value": (
                    "FLOAT",
                    {"multiline": True, "display": "number", "default": 1, "step": 0.01},
                ),
            }
        }
    RETURN_TYPES = ("FLOAT",)
    RETURN_NAMES = ("value",)
    FUNCTION = "run"
    CATEGORY = "number"
    def run(self, input_id, default_value=None, min_value=0, max_value=1):
        try:
            float_value = float(input_id)
            if min_value <= float_value <= max_value:
                print("my number", float_value)
                return [float_value]
            else:
                print("Number out of range. Returning default value:", default_value)
                return [default_value]
        except ValueError:
            print("Invalid input. Returning default value:", default_value)
            return [default_value]
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": ComfyUIDeployExternalNumberSlider}
 NODE_DISPLAY_NAME_MAPPINGS = {"ComfyUIDeployExternalNumberSlider": "External Number Slider (ComfyUI Deploy)"}
@@ -1,78 +0,0 @@
 import os
 import folder_paths
 import uuid
 from tqdm import tqdm
 video_extensions = ["webm", "mp4", "mkv", "gif"]
 class ComfyUIDeployExternalVideo:
    @classmethod
    def INPUT_TYPES(s):
        input_dir = folder_paths.get_input_directory()
        files = []
        for f in os.listdir(input_dir):
            if os.path.isfile(os.path.join(input_dir, f)):
                file_parts = f.split(".")
                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
                    files.append(f)
        return {
            "required": {
                "input_id": (
                    "STRING",
                    {"multiline": False, "default": "input_video"},
                ),
            },
            "optional": {
                "meta_batch": ("VHS_BatchManager",),
                "default_value": (sorted(files),),
            },
        }
    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
    RETURN_TYPES = ("STRING",)
    RETURN_NAMES = ("video")
    FUNCTION = "load_video"
    def load_video(self, input_id, default_value):
        input_dir = folder_paths.get_input_directory()
        if input_id.startswith("http"):
            import requests
            print("Fetching video from URL: ", input_id)
            response = requests.get(input_id, stream=True)
            file_size = int(response.headers.get("Content-Length", 0))
            file_extension = input_id.split(".")[-1].split("?")[
                0
            ]  # Extract extension and handle URLs with parameters
            if file_extension not in video_extensions:
                file_extension = ".mp4"
            unique_filename = str(uuid.uuid4()) + "." + file_extension
            video_path = os.path.join(input_dir, unique_filename)
            chunk_size = 1024  # 1 Kibibyte
            num_bars = int(file_size / chunk_size)
            with open(video_path, "wb") as out_file:
                for chunk in tqdm(
                    response.iter_content(chunk_size=chunk_size),
                    total=num_bars,
                    unit="KB",
                    desc="Downloading",
                    leave=True,
                ):
                    out_file.write(chunk)
        else:
            video_path = os.path.abspath(os.path.join(input_dir, default_value))
        return (video_path,)
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVid": ComfyUIDeployExternalVideo}
 NODE_DISPLAY_NAME_MAPPINGS = {
    "ComfyUIDeployExternalVid": "External Video (ComfyUI Deploy) path"
 }
@@ -1,594 +0,0 @@
 # credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite and is meant to work with
 import os
 import itertools
 import numpy as np
 import torch
 import cv2
 import folder_paths
 from comfy.utils import common_upscale
 ### Utils
 import hashlib
 from typing import Iterable
 import shutil
 import subprocess
 import re
 import uuid
 import server
 from tqdm import tqdm
 BIGMIN = -(2**53 - 1)
 BIGMAX = 2**53 - 1
 DIMMAX = 8192
 def ffmpeg_suitability(path):
    try:
        version = subprocess.run(
            [path, "-version"], check=True, capture_output=True
        ).stdout.decode("utf-8")
    except:
        return 0
    score = 0
    # rough layout of the importance of various features
    simple_criterion = [
        ("libvpx", 20),
        ("264", 10),
        ("265", 3),
        ("svtav1", 5),
        ("libopus", 1),
    ]
    for criterion in simple_criterion:
        if version.find(criterion[0]) >= 0:
            score += criterion[1]
    # obtain rough compile year from copyright information
    copyright_index = version.find("2000-2")
    if copyright_index >= 0:
        copyright_year = version[copyright_index + 6 : copyright_index + 9]
        if copyright_year.isnumeric():
            score += int(copyright_year)
    return score
 if "VHS_FORCE_FFMPEG_PATH" in os.environ:
    ffmpeg_path = os.environ.get("VHS_FORCE_FFMPEG_PATH")
 else:
    ffmpeg_paths = []
    try:
        from imageio_ffmpeg import get_ffmpeg_exe
        imageio_ffmpeg_path = get_ffmpeg_exe()
        ffmpeg_paths.append(imageio_ffmpeg_path)
    except:
        if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
            raise
    if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
        ffmpeg_path = imageio_ffmpeg_path
    else:
        system_ffmpeg = shutil.which("ffmpeg")
        if system_ffmpeg is not None:
            ffmpeg_paths.append(system_ffmpeg)
        if os.path.isfile("ffmpeg"):
            ffmpeg_paths.append(os.path.abspath("ffmpeg"))
        if os.path.isfile("ffmpeg.exe"):
            ffmpeg_paths.append(os.path.abspath("ffmpeg.exe"))
        if len(ffmpeg_paths) == 0:
            ffmpeg_path = None
        elif len(ffmpeg_paths) == 1:
            # Evaluation of suitability isn't required, can take sole option
            # to reduce startup time
            ffmpeg_path = ffmpeg_paths[0]
        else:
            ffmpeg_path = max(ffmpeg_paths, key=ffmpeg_suitability)
 gifski_path = os.environ.get("VHS_GIFSKI", None)
 if gifski_path is None:
    gifski_path = os.environ.get("JOV_GIFSKI", None)
    if gifski_path is None:
        gifski_path = shutil.which("gifski")
 def get_sorted_dir_files_from_directory(
    directory: str,
    skip_first_images: int = 0,
    select_every_nth: int = 1,
    extensions: Iterable = None,
 ):
    directory = directory.strip()
    dir_files = os.listdir(directory)
    dir_files = sorted(dir_files)
    dir_files = [os.path.join(directory, x) for x in dir_files]
    dir_files = list(filter(lambda filepath: os.path.isfile(filepath), dir_files))
    # filter by extension, if needed
    if extensions is not None:
        extensions = list(extensions)
        new_dir_files = []
        for filepath in dir_files:
            ext = "." + filepath.split(".")[-1]
            if ext.lower() in extensions:
                new_dir_files.append(filepath)
        dir_files = new_dir_files
    # start at skip_first_images
    dir_files = dir_files[skip_first_images:]
    dir_files = dir_files[0::select_every_nth]
    return dir_files
 # modified from https://stackoverflow.com/questions/22058048/hashing-a-file-in-python
 def calculate_file_hash(filename: str, hash_every_n: int = 1):
    # Larger video files were taking >.5 seconds to hash even when cached,
    # so instead the modified time from the filesystem is used as a hash
    h = hashlib.sha256()
    h.update(filename.encode())
    h.update(str(os.path.getmtime(filename)).encode())
    return h.hexdigest()
 prompt_queue = server.PromptServer.instance.prompt_queue
 def requeue_workflow_unchecked():
    """Requeues the current workflow without checking for multiple requeues"""
    currently_running = prompt_queue.currently_running
    (_, _, prompt, extra_data, outputs_to_execute) = next(
        iter(currently_running.values())
    )
    # Ensure batch_managers are marked stale
    prompt = prompt.copy()
    for uid in prompt:
        if prompt[uid]["class_type"] == "VHS_BatchManager":
            prompt[uid]["inputs"]["requeue"] = (
                prompt[uid]["inputs"].get("requeue", 0) + 1
            )
    # execution.py has guards for concurrency, but server doesn't.
    # TODO: Check that this won't be an issue
    number = -server.PromptServer.instance.number
    server.PromptServer.instance.number += 1
    prompt_id = str(server.uuid.uuid4())
    prompt_queue.put((number, prompt_id, prompt, extra_data, outputs_to_execute))
 requeue_guard = [None, 0, 0, {}]
 def requeue_workflow(requeue_required=(-1, True)):
    assert len(prompt_queue.currently_running) == 1
    global requeue_guard
    (run_number, _, prompt, _, _) = next(iter(prompt_queue.currently_running.values()))
    if requeue_guard[0] != run_number:
        # Calculate a count of how many outputs are managed by a batch manager
        managed_outputs = 0
        for bm_uid in prompt:
            if prompt[bm_uid]["class_type"] == "VHS_BatchManager":
                for output_uid in prompt:
                    if prompt[output_uid]["class_type"] in ["VHS_VideoCombine"]:
                        for inp in prompt[output_uid]["inputs"].values():
                            if inp == [bm_uid, 0]:
                                managed_outputs += 1
        requeue_guard = [run_number, 0, managed_outputs, {}]
    requeue_guard[1] = requeue_guard[1] + 1
    requeue_guard[3][requeue_required[0]] = requeue_required[1]
    if requeue_guard[1] == requeue_guard[2] and max(requeue_guard[3].values()):
        requeue_workflow_unchecked()
 def get_audio(file, start_time=0, duration=0):
    args = [ffmpeg_path, "-v", "error", "-i", file]
    if start_time > 0:
        args += ["-ss", str(start_time)]
    if duration > 0:
        args += ["-t", str(duration)]
    try:
        res = subprocess.run(
            args + ["-f", "wav", "-"], stdout=subprocess.PIPE, check=True
        ).stdout
    except subprocess.CalledProcessError as e:
        return False
    return res
 def lazy_eval(func):
    class Cache:
        def __init__(self, func):
            self.res = None
            self.func = func
        def get(self):
            if self.res is None:
                self.res = self.func()
            return self.res
    cache = Cache(func)
    return lambda: cache.get()
 def is_url(url):
    return url.split("://")[0] in ["http", "https"]
 def validate_sequence(path):
    # Check if path is a valid ffmpeg sequence that points to at least one file
    (path, file) = os.path.split(path)
    if not os.path.isdir(path):
        return False
    match = re.search("%0?\d+d", file)
    if not match:
        return False
    seq = match.group()
    if seq == "%d":
        seq = "\\\\d+"
    else:
        seq = "\\\\d{%s}" % seq[1:-1]
    file_matcher = re.compile(re.sub("%0?\d+d", seq, file))
    for file in os.listdir(path):
        if file_matcher.fullmatch(file):
            return True
    return False
 def hash_path(path):
    if path is None:
        return "input"
    if is_url(path):
        return "url"
    return calculate_file_hash(path.strip('"'))
 def validate_path(path, allow_none=False, allow_url=True):
    if path is None:
        return allow_none
    if is_url(path):
        # Probably not feasible to check if url resolves here
        return True if allow_url else "URLs are unsupported for this path"
    if not os.path.isfile(path.strip('"')):
        return "Invalid file path: {}".format(path)
    return True
 ### Utils
 video_extensions = ["webm", "mp4", "mkv", "gif"]
 def is_gif(filename) -> bool:
    file_parts = filename.split(".")
    return len(file_parts) > 1 and file_parts[-1] == "gif"
 def target_size(
    width, height, force_size, custom_width, custom_height
 ) -> tuple[int, int]:
    if force_size == "Custom":
        return (custom_width, custom_height)
    elif force_size == "Custom Height":
        force_size = "?x" + str(custom_height)
    elif force_size == "Custom Width":
        force_size = str(custom_width) + "x?"
    if force_size != "Disabled":
        force_size = force_size.split("x")
        if force_size[0] == "?":
            width = (width * int(force_size[1])) // height
            # Limit to a multple of 8 for latent conversion
            width = int(width) + 4 & ~7
            height = int(force_size[1])
        elif force_size[1] == "?":
            height = (height * int(force_size[0])) // width
            height = int(height) + 4 & ~7
            width = int(force_size[0])
        else:
            width = int(force_size[0])
            height = int(force_size[1])
    return (width, height)
 def cv_frame_generator(
    video,
    force_rate,
    frame_load_cap,
    skip_first_frames,
    select_every_nth,
    meta_batch=None,
    unique_id=None,
 ):
    video_cap = cv2.VideoCapture(video)
    if not video_cap.isOpened():
        raise ValueError(f"{video} could not be loaded with cv.")
    # extract video metadata
    fps = video_cap.get(cv2.CAP_PROP_FPS)
    width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
    duration = total_frames / fps
    # set video_cap to look at start_index frame
    total_frame_count = 0
    total_frames_evaluated = -1
    frames_added = 0
    base_frame_time = 1 / fps
    prev_frame = None
    if force_rate == 0:
        target_frame_time = base_frame_time
    else:
        target_frame_time = 1 / force_rate
    yield (width, height, fps, duration, total_frames, target_frame_time)
    time_offset = target_frame_time - base_frame_time
    while video_cap.isOpened():
        if time_offset < target_frame_time:
            is_returned = video_cap.grab()
            # if didn't return frame, video has ended
            if not is_returned:
                break
            time_offset += base_frame_time
        if time_offset < target_frame_time:
            continue
        time_offset -= target_frame_time
        # if not at start_index, skip doing anything with frame
        total_frame_count += 1
        if total_frame_count <= skip_first_frames:
            continue
        else:
            total_frames_evaluated += 1
        # if should not be selected, skip doing anything with frame
        if total_frames_evaluated % select_every_nth != 0:
            continue
        # opencv loads images in BGR format (yuck), so need to convert to RGB for ComfyUI use
        # follow up: can videos ever have an alpha channel?
        # To my testing: No. opencv has no support for alpha
        unused, frame = video_cap.retrieve()
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        # convert frame to comfyui's expected format
        # TODO: frame contains no exif information. Check if opencv2 has already applied
        frame = np.array(frame, dtype=np.float32) / 255.0
        if prev_frame is not None:
            inp = yield prev_frame
            if inp is not None:
                # ensure the finally block is called
                return
        prev_frame = frame
        frames_added += 1
        # if cap exists and we've reached it, stop processing frames
        if frame_load_cap > 0 and frames_added >= frame_load_cap:
            break
    if meta_batch is not None:
        meta_batch.inputs.pop(unique_id)
        meta_batch.has_closed_inputs = True
    if prev_frame is not None:
        yield prev_frame
 def load_video_cv(
    video: str,
    force_rate: int,
    force_size: str,
    custom_width: int,
    custom_height: int,
    frame_load_cap: int,
    skip_first_frames: int,
    select_every_nth: int,
    meta_batch=None,
    unique_id=None,
 ):
    if meta_batch is None or unique_id not in meta_batch.inputs:
        gen = cv_frame_generator(
            video,
            force_rate,
            frame_load_cap,
            skip_first_frames,
            select_every_nth,
            meta_batch,
            unique_id,
        )
        (width, height, fps, duration, total_frames, target_frame_time) = next(gen)
        if meta_batch is not None:
            meta_batch.inputs[unique_id] = (
                gen,
                width,
                height,
                fps,
                duration,
                total_frames,
                target_frame_time,
            )
    else:
        (gen, width, height, fps, duration, total_frames, target_frame_time) = (
            meta_batch.inputs[unique_id]
        )
    if meta_batch is not None:
        gen = itertools.islice(gen, meta_batch.frames_per_batch)
    # Some minor wizardry to eliminate a copy and reduce max memory by a factor of ~2
    images = torch.from_numpy(
        np.fromiter(gen, np.dtype((np.float32, (height, width, 3))))
    )
    if len(images) == 0:
        raise RuntimeError("No frames generated")
    if force_size != "Disabled":
        new_size = target_size(width, height, force_size, custom_width, custom_height)
        if new_size[0] != width or new_size[1] != height:
            s = images.movedim(-1, 1)
            s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
            images = s.movedim(1, -1)
    # Setup lambda for lazy audio capture
    audio = lambda: get_audio(
        video,
        skip_first_frames * target_frame_time,
        frame_load_cap * target_frame_time * select_every_nth,
    )
    # Adjust target_frame_time for select_every_nth
    target_frame_time *= select_every_nth
    video_info = {
        "source_fps": fps,
        "source_frame_count": total_frames,
        "source_duration": duration,
        "source_width": width,
        "source_height": height,
        "loaded_fps": 1 / target_frame_time,
        "loaded_frame_count": len(images),
        "loaded_duration": len(images) * target_frame_time,
        "loaded_width": images.shape[2],
        "loaded_height": images.shape[1],
    }
    return (images, len(images), lazy_eval(audio), video_info)
 class ComfyUIDeployExternalVideo:
    @classmethod
    def INPUT_TYPES(s):
        input_dir = folder_paths.get_input_directory()
        files = []
        for f in os.listdir(input_dir):
            if os.path.isfile(os.path.join(input_dir, f)):
                file_parts = f.split(".")
                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
                    files.append(f)
        return {
            "required": {
                "input_id": (
                    "STRING",
                    {"multiline": False, "default": "input_video"},
                ),
                "force_rate": ("INT", {"default": 0, "min": 0, "max": 60, "step": 1}),
                "force_size": (
                    [
                        "Disabled",
                        "Custom Height",
                        "Custom Width",
                        "Custom",
                        "256x?",
                        "?x256",
                        "256x256",
                        "512x?",
                        "?x512",
                        "512x512",
                    ],
                ),
                "custom_width": (
                    "INT",
                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
                ),
                "custom_height": (
                    "INT",
                    {"default": 512, "min": 0, "max": DIMMAX, "step": 8},
                ),
                "frame_load_cap": (
                    "INT",
                    {"default": 0, "min": 0, "max": BIGMAX, "step": 1},
                ),
                "skip_first_frames": (
                    "INT",
                    {"default": 0, "min": 0, "max": BIGMAX, "step": 1},
                ),
                "select_every_nth": (
                    "INT",
                    {"default": 1, "min": 1, "max": BIGMAX, "step": 1},
                ),
            },
            "optional": {
                "meta_batch": ("VHS_BatchManager",),
                "default_value": (sorted(files),),
            },
            "hidden": {"unique_id": "UNIQUE_ID"},
        }
    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
    RETURN_TYPES = (
        "IMAGE",
        "INT",
        "VHS_AUDIO",
        "VHS_VIDEOINFO",
    )
    RETURN_NAMES = (
        "IMAGE",
        "frame_count",
        "audio",
        "video_info",
    )
    FUNCTION = "load_video"
    def load_video(self, **kwargs):
        input_id = kwargs.get("input_id")
        force_rate = kwargs.get("force_rate")
        force_size = kwargs.get("force_size", "Disabled")
        custom_width = kwargs.get("custom_width")
        custom_height = kwargs.get("custom_height")
        frame_load_cap = kwargs.get("frame_load_cap")
        skip_first_frames = kwargs.get("skip_first_frames")
        select_every_nth = kwargs.get("select_every_nth")
        meta_batch = kwargs.get("meta_batch")
        unique_id = kwargs.get("unique_id")
        video = kwargs.get("default_value")
        video_path = folder_paths.get_annotated_filepath(video.strip('"'))
        input_dir = folder_paths.get_input_directory()
        if input_id.startswith("http"):
            import requests
            print("Fetching video from URL: ", input_id)
            response = requests.get(input_id, stream=True)
            file_size = int(response.headers.get("Content-Length", 0))
            file_extension = input_id.split(".")[-1].split("?")[
                0
            ]  # Extract extension and handle URLs with parameters
            if file_extension not in video_extensions:
                file_extension = ".mp4"
            unique_filename = str(uuid.uuid4()) + "." + file_extension
            video_path = os.path.join(input_dir, unique_filename)
            chunk_size = 1024  # 1 Kibibyte
            num_bars = int(file_size / chunk_size)
            with open(video_path, "wb") as out_file:
                for chunk in tqdm(
                    response.iter_content(chunk_size=chunk_size),
                    total=num_bars,
                    unit="KB",
                    desc="Downloading",
                    leave=True,
                ):
                    out_file.write(chunk)
        print("video path: ", video_path)
        return load_video_cv(
            video=video_path,
            force_rate=force_rate,
            force_size=force_size,
            custom_width=custom_width,
            custom_height=custom_height,
            frame_load_cap=frame_load_cap,
            skip_first_frames=skip_first_frames,
            select_every_nth=select_every_nth,
            meta_batch=meta_batch,
            unique_id=unique_id,
        )
    @classmethod
    def IS_CHANGED(s, video, **kwargs):
        image_path = folder_paths.get_annotated_filepath(video)
        return calculate_file_hash(image_path)
 NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalVideo": ComfyUIDeployExternalVideo}
 NODE_DISPLAY_NAME_MAPPINGS = {
    "ComfyUIDeployExternalVideo": "External Video (ComfyUI Deploy x VHS)"
 }
@@ -30,10 +30,6 @@ api_task = None
 cd_enable_log = os.environ.get('CD_ENABLE_LOG', 'false').lower() == 'true'
 cd_enable_run_log = os.environ.get('CD_ENABLE_RUN_LOG', 'false').lower() == 'true'
 bypass_upload = os.environ.get('CD_BYPASS_UPLOAD', 'false').lower() == 'true'
 print("CD_BYPASS_UPLOAD", bypass_upload)
 def clear_current_prompt(sid):
    prompt_server = server.PromptServer.instance
@@ -122,7 +118,7 @@ def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
                if (value["class_type"] == "ComfyDeployWebscoketImageInput"):
                    value['inputs']["client_id"] = sid
-            if "input_id" in value['inputs'] and inputs is not None and value['inputs']['input_id'] in inputs:
+            if "input_id" in value['inputs'] and value['inputs']['input_id'] in inputs:
                new_value = inputs[value['inputs']['input_id']]
                # Lets skip it if its an image
@@ -141,15 +137,6 @@ def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
                if (value["class_type"] == "ComfyUIDeployExternalImageBatch"):
                    value['inputs']["images"] = new_value
                if value["class_type"] == "ComfyUIDeployExternalLora":
                    value["inputs"]["default_lora_name"] = new_value
                if value["class_type"] == "ComfyUIDeployExternalSlider":
                    value["inputs"]["default_value"] = new_value
                if value["class_type"] == "ComfyUIDeployExternalBoolean":
                    value["inputs"]["default_value"] = new_value
 def send_prompt(sid: str, inputs: StreamingPrompt):
    # workflow_api = inputs.workflow_api
@@ -357,7 +344,7 @@ async def upload_file_endpoint(request):
                        with open(file_path, 'rb') as f:
                            headers = {
                                "Content-Type": file_type,
-                                # "x-amz-acl": "public-read",
+                                "x-amz-acl": "public-read",
                                "Content-Length": str(file_size)
                            }
                            async with session.put(upload_url, data=f, headers=headers) as upload_response:
@@ -828,27 +815,20 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
    target_url = f"{file_upload_endpoint}?file_name={filename}&run_id={prompt_id}&type={content_type}"
    start_time = time.time()  # Start timing here
    result = requests.get(target_url)
    end_time = time.time()  # End timing after the request is complete
    print("Time taken for getting file upload endpoint: {:.2f} seconds".format(end_time - start_time))
    ok = result.json()
    start_time = time.time()  # Start timing here
    with open(file, 'rb') as f:
        data = f.read()
        headers = {
-            # "x-amz-acl": "public-read",
+            "x-amz-acl": "public-read",
            "Content-Type": content_type,
            "Content-Length": str(len(data)),
        }
-        # response = requests.put(ok.get("url"), headers=headers, data=data)
+        response = requests.put(ok.get("url"), headers=headers, data=data)
        async with aiohttp.ClientSession() as session:
            async with session.put(ok.get("url"), headers=headers, data=data) as response:
-                print("Upload file response", response.status)
+                print("upload file response", response.status)
                end_time = time.time()  # End timing after the request is complete
                print("Upload time: {:.2f} seconds".format(end_time - start_time))
 def have_pending_upload(prompt_id):
    if prompt_id in prompt_metadata and len(prompt_metadata[prompt_id].uploading_nodes) > 0:
@@ -934,7 +914,7 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
    # if there are no nodes that are uploading, then we set the status to success
    elif not uploading and not have_pending_upload(prompt_id) and is_prompt_done(prompt_id=prompt_id):
        update_run(prompt_id, Status.SUCCESS)
-        # print("Status: SUCCUSS")
+        print("Status: SUCCUSS")
        await send("success", {
            "prompt_id": prompt_id,
        })
@@ -945,22 +925,12 @@ async def handle_upload(prompt_id: str, data, key: str, content_type_key: str, d
        # # Skipping temp files
        if item.get("type") == "temp":
            continue
        file_type = item.get(content_type_key, default_content_type)
        file_extension = os.path.splitext(item.get("filename"))[1]
        if file_extension in ['.jpg', '.jpeg']:
            file_type = 'image/jpeg'
        elif file_extension == '.png':
            file_type = 'image/png'
        elif file_extension == '.webp':
            file_type = 'image/webp'
        await upload_file(
            prompt_id,
            item.get("filename"),
            subfolder=item.get("subfolder"),
            type=item.get("type"),
-            content_type=file_type
+            content_type=item.get(content_type_key, default_content_type)
        )
 # Upload files in the background
@@ -970,7 +940,6 @@ async def upload_in_background(prompt_id: str, data, node_id=None, have_upload=T
        await handle_upload(prompt_id, data, 'files', "content_type", "image/png")
        # This will also be mp4
        await handle_upload(prompt_id, data, 'gifs', "format", "image/gif")
        await handle_upload(prompt_id, data, 'mesh', "format", "application/octet-stream")
        if have_upload:
            await update_file_status(prompt_id, data, False, node_id=node_id)
@@ -990,23 +959,19 @@ async def update_run_with_output(prompt_id, data, node_id=None):
        "run_id": prompt_id,
        "output_data": data
    }
    have_upload_media = 'images' in data or 'files' in data or 'gifs' in data or 'mesh' in data
    if bypass_upload and have_upload_media:
        print("CD_BYPASS_UPLOAD is enabled, skipping the upload of the output:", node_id)
        return
-    if have_upload_media:
+    try:
-        try:
+        have_upload = 'images' in data or 'files' in data or 'gifs' in data
-            print("\nhave_upload", have_upload_media, node_id)
+        print("\nhave_upload", have_upload, node_id)
-            if have_upload_media:
+        if have_upload:
-                await update_file_status(prompt_id, data, True, node_id=node_id)
+            await update_file_status(prompt_id, data, True, node_id=node_id)
-            asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload_media))
+        asyncio.create_task(upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload))
            # await upload_in_background(prompt_id, data, node_id=node_id, have_upload=have_upload)
-        except Exception as e:
+    except Exception as e:
-            await handle_error(prompt_id, data, e)
+        await handle_error(prompt_id, data, e)
    requests.post(status_endpoint, json=body)
@@ -1062,9 +1027,3 @@ def run_in_new_thread(coroutine):
 if cd_enable_log:
    run_in_new_thread(watch_file_changes(log_file_path, send_logs_to_websocket))
 # use after calling GET /object_info (it populates the `filename_list_cache` variable)
@server.PromptServer.instance.routes.get("/comfyui-deploy/filename_list_cache")
 async def get_filename_list_cache(_):
    from folder_paths import filename_list_cache
    return web.json_response({'filename_list': filename_list_cache})
@@ -1,15 +0,0 @@
 [project]
 name = "comfyui-deploy"
 description = "Open source comfyui deployment platform, a vercel for generative workflow infra."
 version = "1.0.0"
 license = "LICENSE"
 dependencies = ["aiofiles", "pydantic", "opencv-python", "imageio-ffmpeg"]
 [project.urls]
 Repository = "https://github.com/BennyKok/comfyui-deploy"
 #  Used by Comfy Registry https://comfyregistry.org
 [tool.comfy]
 PublisherId = "comfydeploy"
 DisplayName = "comfyui-deploy"
 Icon = ""
@@ -1,4 +1,2 @@
 aiofiles
-pydantic
+pydantic
 opencv-python
 imageio-ffmpeg
@@ -30,30 +30,6 @@ const ext = {
    if (workspace_mode) {
      document.querySelector(".comfy-menu").style.display = "none";
      sendEventToCD("cd_plugin_onInit");
      app.queuePrompt = ((originalFunction) =>
        async () => {
          // const prompt = await app.graphToPrompt();
          sendEventToCD("cd_plugin_onQueuePromptTrigger");
        })(app.queuePrompt);
      // // Intercept the onkeydown event
      // window.addEventListener(
      //   "keydown",
      //   (event) => {
      //     // Check for specific keys if necessary
      //     console.log("hi");
      //     if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
      //       event.preventDefault();
      //       event.stopImmediatePropagation();
      //       event.stopPropagation();
      //       sendEventToCD("cd_plugin_onQueuePrompt", prompt);
      //     }
      //   },
      //   true,
      // );
    }
    const data = getData();
@@ -228,8 +204,7 @@ const ext = {
      //   }
    });
-    app.graph.onAfterChange = ((originalFunction) =>
+    app.graph.onAfterChange = ((originalFunction) => async function () {
      async function () {
        const prompt = await app.graphToPrompt();
        sendEventToCD("cd_plugin_onAfterChange", prompt);
@@ -479,7 +454,9 @@ async function deployWorkflow() {
        console.log(file);
        loadingDialog.showLoading("Generating hash", file);
        const hash = await fetch(
-          `/comfyui-deploy/get-file-hash?file_path=${encodeURIComponent(file)}`,
+          `/comfyui-deploy/get-file-hash?file_path=${encodeURIComponent(
            file,
          )}`,
        ).then((x) => x.json());
        loadingDialog.showLoading("Generating hash", file);
        console.log(hash);
@@ -489,14 +466,17 @@ async function deployWorkflow() {
        console.log("Uploading ", file);
        loadingDialog.showLoading("Uploading file", file);
        try {
-          const { download_url } = await fetch(`/comfyui-deploy/upload-file`, {
+          const { download_url } = await fetch(
-            method: "POST",
+            `/comfyui-deploy/upload-file`,
-            body: JSON.stringify({
+            {
-              file_path: file,
+              method: "POST",
-              token: apiKey,
+              body: JSON.stringify({
-              url: endpoint + "/api/upload-url",
+                file_path: file,
-            }),
+                token: apiKey,
-          })
+                url: endpoint + "/api/upload-url",
              }),
            },
          )
            .then((x) => x.json())
            .catch(() => {
              loadingDialog.close();
@@ -628,7 +608,7 @@ function addButton() {
  deploy.style.display = "block";
  deploy.innerHTML = "<div id='button-title'>Deploy</div>";
  deploy.onclick = async () => {
-    await deployWorkflow();
+    await deployWorkflow()
  };
  const config = document.createElement("img");