fix(upload outputs): skip images/gifs/files/mesh when env var is true

The env var is `CD_BYPASS_UPLOAD`. When that variables is `True`, we don't upload the media to our comfy deploy s3 bucket. There are 2 steps. 1. save the file into our s3 bucket 2. save the saving into our database. When `CD_BYPASS_UPLOAD` is True: 1. Skip the save file into our s3 bucket 2. Skip the save into our database Previously we were skipping the step 1, but not the step 2. So that is the reason of why we keep seeing the comfy deploy URL when fetching the run details: ``` outputs: [ { data:{ gifs: [ { url: "https://comfy-deploy-output.s3.amazonaws.com/video.mp4" } ], text: [ "A text that you displayed with show text node" ] } } ] ``` With the new changes we don't save that into our database, and fetching the details of a run will look like this: ``` outputs: [ { data:{ text: [ "A text that you displayed with show text node" ] } } ] ```
Revert "fix(image upload): skip when using the CD_BYPASS_UPLOAD env var"
2024-07-07 19:16:40 -06:00 · 2024-07-07 18:52:21 -06:00 · 2024-07-06 13:02:30 -06:00
9 changed files with 329 additions and 937 deletions
@@ -5,12 +5,6 @@ import torch
 import folder_paths
 from tqdm import tqdm
 class AnyType(str):
    def __ne__(self, __value: object) -> bool:
        return False
 WILDCARD = AnyType("*")
 class ComfyUIDeployExternalCheckpoint:
    @classmethod
    def INPUT_TYPES(s):
@@ -26,7 +20,7 @@ class ComfyUIDeployExternalCheckpoint:
            }
        }
-    RETURN_TYPES = (WILDCARD,)
+    RETURN_TYPES = (folder_paths.get_filename_list("checkpoints"),)
    RETURN_NAMES = ("path",)
    FUNCTION = "run"
@@ -4,11 +4,6 @@ import numpy as np
 import torch
 import folder_paths
 class AnyType(str):
    def __ne__(self, __value: object) -> bool:
        return False
 WILDCARD = AnyType("*")
 class ComfyUIDeployExternalLora:
    @classmethod
@@ -25,7 +20,7 @@ class ComfyUIDeployExternalLora:
            },
        }
-    RETURN_TYPES = (WILDCARD,)
+    RETURN_TYPES = (folder_paths.get_filename_list("loras"),)
    RETURN_NAMES = ("path",)
    FUNCTION = "run"
@@ -1,15 +1,10 @@
-# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite
+# credit goes to https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite and is meant to work with
 # Intended to work with https://github.com/NicholasKao1029/ComfyUI-VideoHelperSuite/tree/main
 import os
 import itertools
 import numpy as np
 import torch
 from typing import Union
 from torch import Tensor
 import cv2
 import psutil
 from collections.abc import Mapping
 import folder_paths
 from comfy.utils import common_upscale
@@ -95,25 +90,13 @@ if gifski_path is None:
        gifski_path = shutil.which("gifski")
 def is_safe_path(path):
    if "VHS_STRICT_PATHS" not in os.environ:
        return True
    basedir = os.path.abspath(".")
    try:
        common_path = os.path.commonpath([basedir, path])
    except:
        # Different drive on windows
        return False
    return common_path == basedir
 def get_sorted_dir_files_from_directory(
    directory: str,
    skip_first_images: int = 0,
    select_every_nth: int = 1,
    extensions: Iterable = None,
 ):
-    directory = strip_path(directory)
+    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]
@@ -194,59 +177,18 @@ def requeue_workflow(requeue_required=(-1, True)):
 def get_audio(file, start_time=0, duration=0):
-    args = [ffmpeg_path, "-i", file]
+    args = [ffmpeg_path, "-v", "error", "-i", file]
    if start_time > 0:
        args += ["-ss", str(start_time)]
    if duration > 0:
        args += ["-t", str(duration)]
    try:
        # TODO: scan for sample rate and maintain
        res = subprocess.run(
-            args + ["-f", "f32le", "-"], capture_output=True, check=True
+            args + ["-f", "wav", "-"], stdout=subprocess.PIPE, check=True
-        )
+        ).stdout
        audio = torch.frombuffer(bytearray(res.stdout), dtype=torch.float32)
        match = re.search(", (\\d+) Hz, (\\w+), ", res.stderr.decode("utf-8"))
    except subprocess.CalledProcessError as e:
-        raise Exception(
+        return False
-            f"VHS failed to extract audio from {file}:\n" + e.stderr.decode("utf-8")
+    return res
        )
    if match:
        ar = int(match.group(1))
        # NOTE: Just throwing an error for other channel types right now
        # Will deal with issues if they come
        ac = {"mono": 1, "stereo": 2}[match.group(2)]
    else:
        ar = 44100
        ac = 2
    audio = audio.reshape((-1, ac)).transpose(0, 1).unsqueeze(0)
    return {"waveform": audio, "sample_rate": ar}
 class LazyAudioMap(Mapping):
    def __init__(self, file, start_time, duration):
        self.file = file
        self.start_time = start_time
        self.duration = duration
        self._dict = None
    def __getitem__(self, key):
        if self._dict is None:
            self._dict = get_audio(self.file, self.start_time, self.duration)
        return self._dict[key]
    def __iter__(self):
        if self._dict is None:
            self._dict = get_audio(self.file, self.start_time, self.duration)
        return iter(self._dict)
    def __len__(self):
        if self._dict is None:
            self._dict = get_audio(self.file, self.start_time, self.duration)
        return len(self._dict)
 def lazy_get_audio(file, start_time=0, duration=0):
    return LazyAudioMap(file, start_time, duration)
 def lazy_eval(func):
@@ -288,19 +230,6 @@ def validate_sequence(path):
    return False
 def strip_path(path):
    # This leaves whitespace inside quotes and only a single "
    # thus ' ""test"' -> '"test'
    # consider path.strip(string.whitespace+"\"")
    # or weightier re.fullmatch("[\\s\"]*(.+?)[\\s\"]*", path).group(1)
    path = path.strip()
    if path.startswith('"'):
        path = path[1:]
    if path.endswith('"'):
        path = path[:-1]
    return path
 def hash_path(path):
    if path is None:
        return "input"
@@ -357,145 +286,6 @@ def target_size(
    return (width, height)
 def validate_index(
    index: int,
    length: int = 0,
    is_range: bool = False,
    allow_negative=False,
    allow_missing=False,
 ) -> int:
    # if part of range, do nothing
    if is_range:
        return index
    # otherwise, validate index
    # validate not out of range - only when latent_count is passed in
    if length > 0 and index > length - 1 and not allow_missing:
        raise IndexError(f"Index '{index}' out of range for {length} item(s).")
    # if negative, validate not out of range
    if index < 0:
        if not allow_negative:
            raise IndexError(f"Negative indeces not allowed, but was '{index}'.")
        conv_index = length + index
        if conv_index < 0 and not allow_missing:
            raise IndexError(
                f"Index '{index}', converted to '{conv_index}' out of range for {length} item(s)."
            )
        index = conv_index
    return index
 def convert_to_index_int(
    raw_index: str,
    length: int = 0,
    is_range: bool = False,
    allow_negative=False,
    allow_missing=False,
 ) -> int:
    try:
        return validate_index(
            int(raw_index),
            length=length,
            is_range=is_range,
            allow_negative=allow_negative,
            allow_missing=allow_missing,
        )
    except ValueError as e:
        raise ValueError(f"Index '{raw_index}' must be an integer.", e)
 def convert_str_to_indexes(
    indexes_str: str, length: int = 0, allow_missing=False
 ) -> list[int]:
    if not indexes_str:
        return []
    int_indexes = list(range(0, length))
    allow_negative = length > 0
    chosen_indexes = []
    # parse string - allow positive ints, negative ints, and ranges separated by ':'
    groups = indexes_str.split(",")
    groups = [g.strip() for g in groups]
    for g in groups:
        # parse range of indeces (e.g. 2:16)
        if ":" in g:
            index_range = g.split(":", 2)
            index_range = [r.strip() for r in index_range]
            start_index = index_range[0]
            if len(start_index) > 0:
                start_index = convert_to_index_int(
                    start_index,
                    length=length,
                    is_range=True,
                    allow_negative=allow_negative,
                    allow_missing=allow_missing,
                )
            else:
                start_index = 0
            end_index = index_range[1]
            if len(end_index) > 0:
                end_index = convert_to_index_int(
                    end_index,
                    length=length,
                    is_range=True,
                    allow_negative=allow_negative,
                    allow_missing=allow_missing,
                )
            else:
                end_index = length
            # support step as well, to allow things like reversing, every-other, etc.
            step = 1
            if len(index_range) > 2:
                step = index_range[2]
                if len(step) > 0:
                    step = convert_to_index_int(
                        step,
                        length=length,
                        is_range=True,
                        allow_negative=True,
                        allow_missing=True,
                    )
                else:
                    step = 1
            # if latents were passed in, base indeces on known latent count
            if len(int_indexes) > 0:
                chosen_indexes.extend(int_indexes[start_index:end_index][::step])
            # otherwise, assume indeces are valid
            else:
                chosen_indexes.extend(list(range(start_index, end_index, step)))
        # parse individual indeces
        else:
            chosen_indexes.append(
                convert_to_index_int(
                    g,
                    length=length,
                    allow_negative=allow_negative,
                    allow_missing=allow_missing,
                )
            )
    return chosen_indexes
 def select_indexes(input_obj: Union[Tensor, list], idxs: list):
    if type(input_obj) == Tensor:
        return input_obj[idxs]
    else:
        return [input_obj[i] for i in idxs]
 def select_indexes_from_str(
    input_obj: Union[Tensor, list], indexes: str, err_if_missing=True, err_if_empty=True
 ):
    real_idxs = convert_str_to_indexes(
        indexes, len(input_obj), allow_missing=not err_if_missing
    )
    if err_if_empty and len(real_idxs) == 0:
        raise Exception(f"Nothing was selected based on indexes found in '{indexes}'.")
    return select_indexes(input_obj, real_idxs)
 ###
 def cv_frame_generator(
    video,
    force_rate,
@@ -505,10 +295,9 @@ def cv_frame_generator(
    meta_batch=None,
    unique_id=None,
 ):
-    video_cap = cv2.VideoCapture(strip_path(video))
+    video_cap = cv2.VideoCapture(video)
    if not video_cap.isOpened():
        raise ValueError(f"{video} could not be loaded with cv.")
    pbar = None
    # extract video metadata
    fps = video_cap.get(cv2.CAP_PROP_FPS)
@@ -530,8 +319,6 @@ def cv_frame_generator(
        target_frame_time = 1 / force_rate
    yield (width, height, fps, duration, total_frames, target_frame_time)
    if meta_batch is not None:
        yield min(frame_load_cap, total_frames)
    time_offset = target_frame_time - base_frame_time
    while video_cap.isOpened():
@@ -562,8 +349,7 @@ def cv_frame_generator(
        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)
+        frame = np.array(frame, dtype=np.float32) / 255.0
        torch.from_numpy(frame).div_(255)
        if prev_frame is not None:
            inp = yield prev_frame
            if inp is not None:
@@ -571,8 +357,6 @@ def cv_frame_generator(
                return
        prev_frame = frame
        frames_added += 1
        if pbar is not None:
            pbar.update_absolute(frames_added, frame_load_cap)
        # if cap exists and we've reached it, stop processing frames
        if frame_load_cap > 0 and frames_added >= frame_load_cap:
            break
@@ -583,17 +367,6 @@ def cv_frame_generator(
        yield prev_frame
 def batched(it, n):
    while batch := tuple(itertools.islice(it, n)):
        yield batch
 def batched_vae_encode(images, vae, frames_per_batch):
    for batch in batched(images, frames_per_batch):
        image_batch = torch.from_numpy(np.array(batch))
        yield from vae.encode(image_batch).numpy()
 def load_video_cv(
    video: str,
    force_rate: int,
@@ -605,8 +378,6 @@ def load_video_cv(
    select_every_nth: int,
    meta_batch=None,
    unique_id=None,
    memory_limit_mb=None,
    vae=None,
 ):
    if meta_batch is None or unique_id not in meta_batch.inputs:
        gen = cv_frame_generator(
@@ -630,89 +401,30 @@ def load_video_cv(
                total_frames,
                target_frame_time,
            )
            meta_batch.total_frames = min(meta_batch.total_frames, next(gen))
    else:
        (gen, width, height, fps, duration, total_frames, target_frame_time) = (
            meta_batch.inputs[unique_id]
        )
-    memory_limit = None
+    if meta_batch is not None:
-    if memory_limit_mb is not None:
+        gen = itertools.islice(gen, meta_batch.frames_per_batch)
        memory_limit *= 2**20
    else:
        # TODO: verify if garbage collection should be performed here.
        # leaves ~128 MB unreserved for safety
        try:
            memory_limit = (
                psutil.virtual_memory().available + psutil.swap_memory().free
            ) - 2**27
        except:
            print(
                "Failed to calculate available memory. Memory load limit has been disabled"
            )
    if memory_limit is not None:
        if vae is not None:
            # space required to load as f32, exist as latent with wiggle room, decode to f32
            max_loadable_frames = int(
                memory_limit // (width * height * 3 * (4 + 4 + 1 / 10))
            )
        else:
            # TODO: use better estimate for when vae is not None
            # Consider completely ignoring for load_latent case?
            max_loadable_frames = int(memory_limit // (width * height * 3 * (0.1)))
        if meta_batch is not None:
            if meta_batch.frames_per_batch > max_loadable_frames:
                raise RuntimeError(
                    f"Meta Batch set to {meta_batch.frames_per_batch} frames but only {max_loadable_frames} can fit in memory"
                )
            gen = itertools.islice(gen, meta_batch.frames_per_batch)
        else:
            original_gen = gen
            gen = itertools.islice(gen, max_loadable_frames)
    downscale_ratio = getattr(vae, "downscale_ratio", 8)
    frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
    if force_size != "Disabled" or vae is not None:
        new_size = target_size(
            width, height, force_size, custom_width, custom_height, downscale_ratio
        )
        if new_size[0] != width or new_size[1] != height:
-            def rescale(frame):
+    # Some minor wizardry to eliminate a copy and reduce max memory by a factor of ~2
-                s = torch.from_numpy(
+    images = torch.from_numpy(
-                    np.fromiter(frame, np.dtype((np.float32, (height, width, 3))))
+        np.fromiter(gen, np.dtype((np.float32, (height, width, 3))))
-                )
+    )
                s = s.movedim(-1, 1)
                s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
                return s.movedim(1, -1).numpy()
            gen = itertools.chain.from_iterable(
                map(rescale, batched(gen, frames_per_batch))
            )
    else:
        new_size = width, height
    if vae is not None:
        gen = batched_vae_encode(gen, vae, frames_per_batch)
        vw, vh = new_size[0] // downscale_ratio, new_size[1] // downscale_ratio
        images = torch.from_numpy(np.fromiter(gen, np.dtype((np.float32, (4, vh, vw)))))
    else:
        # 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, (new_size[1], new_size[0], 3))))
        )
    if meta_batch is None and memory_limit is not None:
        try:
            next(original_gen)
            raise RuntimeError(
                f"Memory limit hit after loading {len(images)} frames. Stopping execution."
            )
        except StopIteration:
            pass
    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 = lazy_get_audio(
+    audio = lambda: get_audio(
        video,
        skip_first_frames * target_frame_time,
        frame_load_cap * target_frame_time * select_every_nth,
@@ -728,16 +440,13 @@ def load_video_cv(
        "loaded_fps": 1 / target_frame_time,
        "loaded_frame_count": len(images),
        "loaded_duration": len(images) * target_frame_time,
-        "loaded_width": new_size[0],
+        "loaded_width": images.shape[2],
-        "loaded_height": new_size[1],
+        "loaded_height": images.shape[1],
    }
-    if vae is None:
+
-        return (images, len(images), audio, video_info, None)
+    return (images, len(images), lazy_eval(audio), video_info)
    else:
        return (None, len(images), audio, video_info, {"samples": images})
 # modeled after Video upload node
 class ComfyUIDeployExternalVideo:
    @classmethod
    def INPUT_TYPES(s):
@@ -748,38 +457,68 @@ class ComfyUIDeployExternalVideo:
                file_parts = f.split(".")
                if len(file_parts) > 1 and (file_parts[-1] in video_extensions):
                    files.append(f)
-        return {"required": {
+        return {
-                    "input_id": (
+            "required": {
-                        "STRING",
+                "input_id": (
-                        {"multiline": False, "default": "input_video"},
+                    "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"],),
+                "force_rate": ("INT", {"default": 0, "min": 0, "max": 60, "step": 1}),
-                     "custom_width": ("INT", {"default": 512, "min": 0, "max": DIMMAX, "step": 8}),
+                "force_size": (
-                     "custom_height": ("INT", {"default": 512, "min": 0, "max": DIMMAX, "step": 8}),
+                    [
-                     "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                        "Disabled",
-                     "skip_first_frames": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                        "Custom Height",
-                     "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                        "Custom Width",
-                     },
+                        "Custom",
-                "optional": {
+                        "256x?",
-                    "meta_batch": ("VHS_BatchManager",),
+                        "?x256",
-                    "vae": ("VAE",),
+                        "256x256",
-                    "default_value": (sorted(files),),
+                        "512x?",
-                },
+                        "?x512",
-                "hidden": {
+                        "512x512",
-                    "unique_id": "UNIQUE_ID"
+                    ],
-                },
+                ),
-                }
+                "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", "AUDIO", "VHS_VIDEOINFO", "LATENT")
+    RETURN_TYPES = (
        "IMAGE",
        "INT",
        "VHS_AUDIO",
        "VHS_VIDEOINFO",
    )
    RETURN_NAMES = (
        "IMAGE",
        "frame_count",
        "audio",
        "video_info",
        "LATENT",
    )
    FUNCTION = "load_video"
@@ -18,127 +18,13 @@ import threading
 import hashlib
 import aiohttp
 import aiofiles
-from typing import Dict, List, Union, Any, Optional
+from typing import List, Union, Any, Optional
 from PIL import Image
 import copy
 import struct
 from aiohttp import ClientError
 import atexit
 # Global session
 client_session = None
 # def create_client_session():
 #     global client_session
 #     if client_session is None:
 #         client_session = aiohttp.ClientSession()
 async def ensure_client_session():
    global client_session
    if client_session is None:
        client_session = aiohttp.ClientSession()
 async def cleanup():
    global client_session
    if client_session:
        await client_session.close()
 def exit_handler():
    print("Exiting the application. Initiating cleanup...")
    loop = asyncio.get_event_loop()
    loop.run_until_complete(cleanup())
 atexit.register(exit_handler)
 max_retries = int(os.environ.get('MAX_RETRIES', '3'))
 retry_delay_multiplier = float(os.environ.get('RETRY_DELAY_MULTIPLIER', '2'))
 print(f"max_retries: {max_retries}, retry_delay_multiplier: {retry_delay_multiplier}")
 async def async_request_with_retry(method, url, **kwargs):
    global client_session
    await ensure_client_session()
    retry_delay = 1  # Start with 1 second delay
    for attempt in range(max_retries):
        try:
            async with client_session.request(method, url, **kwargs) as response:
                response.raise_for_status()
                return response
        except ClientError as e:
            if attempt == max_retries - 1:
                logger.error(f"Request failed after {max_retries} attempts: {e}")
                # raise
            logger.warning(f"Request failed (attempt {attempt + 1}/{max_retries}): {e}")
            await asyncio.sleep(retry_delay)
            retry_delay *= retry_delay_multiplier  # Exponential backoff
 from logging import basicConfig, getLogger
 # Check for an environment variable to enable/disable Logfire
 use_logfire = os.environ.get('USE_LOGFIRE', 'false').lower() == 'true'
 if use_logfire:
    try:
        import logfire
        logfire.configure(
            send_to_logfire="if-token-present"
        )
        logger = logfire
    except ImportError:
        print("Logfire not installed or disabled. Using standard Python logger.")
        use_logfire = False
 if not use_logfire:
    # Use a standard Python logger when Logfire is disabled or not available
    logger = getLogger("comfy-deploy")
    basicConfig(level="INFO")  # You can adjust the logging level as needed
 def log(level, message, **kwargs):
    if use_logfire:
        getattr(logger, level)(message, **kwargs)
    else:
        getattr(logger, level)(f"{message} {kwargs}")
 # For a span, you might need to create a context manager
 from contextlib import contextmanager
@contextmanager
 def log_span(name):
    if use_logfire:
        with logger.span(name):
            yield
    # else:
    #     logger.info(f"Start: {name}")
    #     yield
    #     logger.info(f"End: {name}")
 from globals import StreamingPrompt, Status, sockets, SimplePrompt, streaming_prompt_metadata, prompt_metadata
 class EventEmitter:
    def __init__(self):
        self.listeners = {}
    def on(self, event, listener):
        if event not in self.listeners:
            self.listeners[event] = []
        self.listeners[event].append(listener)
    def off(self, event, listener):
        if event in self.listeners:
            self.listeners[event].remove(listener)
            if not self.listeners[event]:
                del self.listeners[event]
    def emit(self, event, *args, **kwargs):
        if event in self.listeners:
            for listener in self.listeners[event]:
                listener(*args, **kwargs)
 # Create a global event emitter instance
 event_emitter = EventEmitter()
 api = None
 api_task = None
@@ -146,18 +32,18 @@ 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'
-logger.info(f"CD_BYPASS_UPLOAD {bypass_upload}")
+print("CD_BYPASS_UPLOAD", bypass_upload)
 def clear_current_prompt(sid):
    prompt_server = server.PromptServer.instance
    to_delete = list(streaming_prompt_metadata[sid].running_prompt_ids)  # Convert set to list
-    logger.info(f"clearing out prompt: {to_delete}")
+    print("clearning out prompt: ", to_delete)
    for id_to_delete in to_delete:
        delete_func = lambda a: a[1] == id_to_delete
        prompt_server.prompt_queue.delete_queue_item(delete_func)
-        logger.info(f"deleted prompt: {id_to_delete}, remaining tasks: {prompt_server.prompt_queue.get_tasks_remaining()}")
+        print("deleted prompt: ", id_to_delete, prompt_server.prompt_queue.get_tasks_remaining())
    streaming_prompt_metadata[sid].running_prompt_ids.clear()
@@ -198,7 +84,7 @@ def post_prompt(json_data):
            }
            return response
        else:
-            logger.info("invalid prompt:", valid[1])
+            print("invalid prompt:", valid[1])
            return {"error": valid[1], "node_errors": valid[3]}
    else:
        return {"error": "no prompt", "node_errors": []}
@@ -272,11 +158,11 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
    # Random seed
    apply_random_seed_to_workflow(workflow_api)
-    logger.info("getting inputs" , inputs.inputs)
+    print("getting inputs" , inputs.inputs)
    apply_inputs_to_workflow(workflow_api, inputs.inputs, sid=sid)
-    logger.info(workflow_api)
+    print(workflow_api)
    prompt_id = str(uuid.uuid4())
@@ -299,11 +185,12 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
        error_type = type(e).__name__
        stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
        stack_trace = traceback.format_exc().strip()
-        logger.info(f"error: {error_type}, {e}")
+        print(f"error: {error_type}, {e}")
-        logger.info(f"stack trace: {stack_trace_short}")
+        print(f"stack trace: {stack_trace_short}")
@server.PromptServer.instance.routes.post("/comfyui-deploy/run")
 async def comfy_deploy_run(request):
    prompt_server = server.PromptServer.instance
    data = await request.json()
    # In older version, we use workflow_api, but this has inputs already swapped in nextjs frontend, which is tricky
@@ -334,8 +221,8 @@ async def comfy_deploy_run(request):
        error_type = type(e).__name__
        stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
        stack_trace = traceback.format_exc().strip()
-        logger.info(f"error: {error_type}, {e}")
+        print(f"error: {error_type}, {e}")
-        logger.info(f"stack trace: {stack_trace_short}")
+        print(f"stack trace: {stack_trace_short}")
        await update_run_with_output(prompt_id, {
            "error": {
                "error_type": error_type,
@@ -347,6 +234,13 @@ async def comfy_deploy_run(request):
        return web.Response(status=500, reason=f"{error_type}: {e}, {stack_trace_short}")
    status = 200
    # if "error" in res:
    #     status = 400
    #     await update_run_with_output(prompt_id, {
    #         "error": {
    #             **res
    #         }
    #     })
    if "node_errors" in res and res["node_errors"]:
        # Even tho there are node_errors it can still be run
@@ -363,134 +257,24 @@ async def comfy_deploy_run(request):
    return web.json_response(res, status=status)
 async def stream_prompt(data):
    # In older version, we use workflow_api, but this has inputs already swapped in nextjs frontend, which is tricky
    workflow_api = data.get("workflow_api_raw")
    # The prompt id generated from comfy deploy, can be None
    prompt_id = data.get("prompt_id")
    inputs = data.get("inputs")
    # Now it handles directly in here
    apply_random_seed_to_workflow(workflow_api)
    apply_inputs_to_workflow(workflow_api, inputs)
    prompt = {
        "prompt": workflow_api,
        "client_id": "comfy_deploy_instance", #api.client_id
        "prompt_id": prompt_id
    }
    prompt_metadata[prompt_id] = SimplePrompt(
        status_endpoint=data.get('status_endpoint'),
        file_upload_endpoint=data.get('file_upload_endpoint'),
        workflow_api=workflow_api
    )
    log('info', "Begin prompt", prompt=prompt)
    try:
        res = post_prompt(prompt)
    except Exception as e:
        error_type = type(e).__name__
        stack_trace_short = traceback.format_exc().strip().split('\n')[-2]
        stack_trace = traceback.format_exc().strip()
        logger.info(f"error: {error_type}, {e}")
        logger.info(f"stack trace: {stack_trace_short}")
        await update_run_with_output(prompt_id, {
            "error": {
                "error_type": error_type,
                "stack_trace": stack_trace
            }
        })
         # When there are critical errors, the prompt is actually not run
        await update_run(prompt_id, Status.FAILED)
        # return web.Response(status=500, reason=f"{error_type}: {e}, {stack_trace_short}")
        # raise Exception("Prompt failed")
    status = 200
    if "node_errors" in res and res["node_errors"]:
        # Even tho there are node_errors it can still be run
        status = 400
        await update_run_with_output(prompt_id, {
            "error": {
                **res
            }
        })
        # When there are critical errors, the prompt is actually not run
        if "error" in res:
            await update_run(prompt_id, Status.FAILED)
            # raise Exception("Prompt failed")
    return res
    # return web.json_response(res, status=status)
 comfy_message_queues: Dict[str, asyncio.Queue] = {}
@server.PromptServer.instance.routes.post('/comfyui-deploy/run/streaming')
 async def stream_response(request):
    response = web.StreamResponse(status=200, reason='OK', headers={'Content-Type': 'text/event-stream'})
    await response.prepare(request)
    pending = True
    data = await request.json()
    prompt_id = data.get("prompt_id")
    comfy_message_queues[prompt_id] = asyncio.Queue()
    with log_span('Streaming Run'):
        log('info', 'Streaming prompt')
        try:
            result = await stream_prompt(data=data)
            await response.write(f"event: event_update\ndata: {json.dumps(result)}\n\n".encode('utf-8'))
            # await response.write(.encode('utf-8'))
            await response.drain()  # Ensure the buffer is flushed
            while pending:
                if prompt_id in comfy_message_queues:
                    if not comfy_message_queues[prompt_id].empty():
                        data = await comfy_message_queues[prompt_id].get()
                        log('info', data["event"], data=json.dumps(data))
                        # logger.info("listener", data)
                        await response.write(f"event: event_update\ndata: {json.dumps(data)}\n\n".encode('utf-8'))
                        await response.drain()  # Ensure the buffer is flushed
                        if data["event"] == "status":
                            if data["data"]["status"] in (Status.FAILED.value, Status.SUCCESS.value):
                                pending = False
                await asyncio.sleep(0.1)  # Adjust the sleep duration as needed
        except asyncio.CancelledError:
            log('info', "Streaming was cancelled")
            raise
        except Exception as e:
            log('error', "Streaming error", error=e)
        finally:
            # event_emitter.off("send_json", task)
            await response.write_eof()
            comfy_message_queues.pop(prompt_id, None)
            return response
 def get_comfyui_path_from_file_path(file_path):
    file_path_parts = file_path.split("\\")
    if file_path_parts[0] == "input":
-        logger.info("matching input")
+        print("matching input")
        file_path = os.path.join(folder_paths.get_directory_by_type("input"), *file_path_parts[1:])
    elif file_path_parts[0] == "models":
-        logger.info("matching models")
+        print("matching models")
        file_path = folder_paths.get_full_path(file_path_parts[1], os.path.join(*file_path_parts[2:]))
-    logger.info(file_path)
+    print(file_path)
    return file_path
 # Form ComfyUI Manager
 async def compute_sha256_checksum(filepath):
-    logger.info("computing sha256 checksum")
+    print("computing sha256 checksum")
    chunk_size = 1024 * 256  # Example: 256KB
    filepath = get_comfyui_path_from_file_path(filepath)
    """Compute the SHA256 checksum of a file, in chunks, asynchronously"""
@@ -513,7 +297,7 @@ async def get_installed_models(request):
        file_list = folder_paths.get_filename_list(key)
        value_json_compatible = (value[0], list(value[1]), file_list)
        new_dict[key] = value_json_compatible
-    # logger.info(new_dict)
+    # print(new_dict)
    return web.json_response(new_dict)
 # This is start uploading the files to Comfy Deploy
@@ -523,7 +307,7 @@ async def upload_file_endpoint(request):
    file_path = data.get("file_path")
-    logger.info("Original file path", file_path)
+    print("Original file path", file_path)
    file_path = get_comfyui_path_from_file_path(file_path)
@@ -562,33 +346,34 @@ async def upload_file_endpoint(request):
    if get_url:
        try:
-            headers = {'Authorization': f'Bearer {token}'}
+            async with aiohttp.ClientSession() as session:
-            params = {'file_size': file_size, 'type': file_type}
+                headers = {'Authorization': f'Bearer {token}'}
-            response = await async_request_with_retry('GET', get_url, params=params, headers=headers)
+                params = {'file_size': file_size, 'type': file_type}
-            if response.status == 200:
+                async with session.get(get_url, params=params, headers=headers) as response:
-                content = await response.json()
+                    if response.status == 200:
-                upload_url = content["upload_url"]
+                        content = await response.json()
                        upload_url = content["upload_url"]
-                with open(file_path, 'rb') as f:
+                        with open(file_path, 'rb') as f:
-                    headers = {
+                            headers = {
-                        "Content-Type": file_type,
+                                "Content-Type": file_type,
-                        # "x-amz-acl": "public-read",
+                                # "x-amz-acl": "public-read",
-                        "Content-Length": str(file_size)
+                                "Content-Length": str(file_size)
-                    }
+                            }
-                    upload_response = await async_request_with_retry('PUT', upload_url, data=f, headers=headers)
+                            async with session.put(upload_url, data=f, headers=headers) as upload_response:
-                    if upload_response.status == 200:
+                                if upload_response.status == 200:
-                        return web.json_response({
+                                    return web.json_response({
-                            "message": "File uploaded successfully",
+                                        "message": "File uploaded successfully",
-                            "download_url": content["download_url"]
+                                        "download_url": content["download_url"]
-                        })
+                                    })
                                else:
                                    return web.json_response({
                                        "error": f"Failed to upload file to {upload_url}. Status code: {upload_response.status}"
                                    }, status=upload_response.status)
                    else:
                        return web.json_response({
-                            "error": f"Failed to upload file to {upload_url}. Status code: {upload_response.status}"
+                            "error": f"Failed to fetch data from {get_url}. Status code: {response.status}"
-                        }, status=upload_response.status)
+                        }, status=response.status)
            else:
                return web.json_response({
                    "error": f"Failed to fetch data from {get_url}. Status code: {response.status}"
                }, status=response.status)
        except Exception as e:
            return web.json_response({
                "error": f"An error occurred while fetching data from {get_url}: {str(e)}"
@@ -644,7 +429,7 @@ async def get_file_hash(request):
            file_hash = await compute_sha256_checksum(full_file_path)
            end_time = time.time()
            elapsed_time = end_time - start_time
-            logger.info(f"Cache miss -> Execution time: {elapsed_time} seconds")
+            print(f"Cache miss -> Execution time: {elapsed_time} seconds")
            # Update the in-memory cache
            file_hash_cache[full_file_path] = file_hash
@@ -664,10 +449,10 @@ async def update_realtime_run_status(realtime_id: str, status_endpoint: str, sta
        "run_id": realtime_id,
        "status": status.value,
    }
    if (status_endpoint is None):
        return
    # requests.post(status_endpoint, json=body)
-    await async_request_with_retry('POST', status_endpoint, json=body)
+    async with aiohttp.ClientSession() as session:
        async with session.post(status_endpoint, json=body) as response:
            pass
@server.PromptServer.instance.routes.get('/comfyui-deploy/ws')
 async def websocket_handler(request):
@@ -688,27 +473,28 @@ async def websocket_handler(request):
    status_endpoint = request.rel_url.query.get('status_endpoint', None)
    if auth_token is not None and get_workflow_endpoint_url is not None:
-        headers = {'Authorization': f'Bearer {auth_token}'}
+        async with aiohttp.ClientSession() as session:
-        response = await async_request_with_retry('GET', get_workflow_endpoint_url, headers=headers)
+            headers = {'Authorization': f'Bearer {auth_token}'}
-        if response.status == 200:
+            async with session.get(get_workflow_endpoint_url, headers=headers) as response:
-            workflow = await response.json()
+                if response.status == 200:
                    workflow = await response.json()
-            logger.info(f"Loaded workflow version ${workflow['version']}")
+                    print("Loaded workflow version ",workflow["version"])
-            streaming_prompt_metadata[sid] = StreamingPrompt(
+                    streaming_prompt_metadata[sid] = StreamingPrompt(
-                workflow_api=workflow["workflow_api"],
+                        workflow_api=workflow["workflow_api"], 
-                auth_token=auth_token,
+                        auth_token=auth_token,
-                inputs={},
+                        inputs={},
-                status_endpoint=status_endpoint,
+                        status_endpoint=status_endpoint,
-                file_upload_endpoint=request.rel_url.query.get('file_upload_endpoint', None),
+                        file_upload_endpoint=request.rel_url.query.get('file_upload_endpoint', None),
-            )
+                    )
-            await update_realtime_run_status(realtime_id, status_endpoint, Status.RUNNING)
+                    await update_realtime_run_status(realtime_id, status_endpoint, Status.RUNNING)
-            # await send("workflow_api", workflow_api, sid)
+                    # await send("workflow_api", workflow_api, sid)
-        else:
+                else:
-            error_message = await response.text()
+                    error_message = await response.text()
-            logger.info(f"Failed to fetch workflow endpoint. Status: {response.status}, Error: {error_message}")
+                    print(f"Failed to fetch workflow endpoint. Status: {response.status}, Error: {error_message}")
-            # await send("error", {"message": error_message}, sid)
+                    # await send("error", {"message": error_message}, sid)
    try:
        # Send initial state to the new client
@@ -722,10 +508,10 @@ async def websocket_handler(request):
            if msg.type == aiohttp.WSMsgType.TEXT:
                try:
                    data = json.loads(msg.data)
-                    logger.info(data)
+                    print(data)
                    event_type = data.get('event')
                    if event_type == 'input':
-                        logger.info(f"Got input: ${data.get('inputs')}")
+                        print("Got input: ", data.get("inputs"))
                        input = data.get('inputs')
                        streaming_prompt_metadata[sid].inputs.update(input)
                    elif event_type == 'queue_prompt':
@@ -735,7 +521,7 @@ async def websocket_handler(request):
                        # Handle other event types
                        pass
                except json.JSONDecodeError:
-                    logger.info('Failed to decode JSON from message')
+                    print('Failed to decode JSON from message')
            if msg.type == aiohttp.WSMsgType.BINARY:
                data = msg.data
@@ -744,9 +530,9 @@ async def websocket_handler(request):
                    image_type_code, = struct.unpack("<I", data[4:8])
                    input_id_bytes = data[8:32]  # Extract the next 24 bytes for the input ID
                    input_id = input_id_bytes.decode('ascii').strip()  # Decode the input ID from ASCII
-                    logger.info(event_type)
+                    print(event_type)
-                    logger.info(image_type_code)
+                    print(image_type_code)
-                    logger.info(input_id)
+                    print(input_id)
                    image_data = data[32:]  # The rest is the image data
                    if image_type_code == 1:
                        image_type = "JPEG"
@@ -755,7 +541,7 @@ async def websocket_handler(request):
                    elif image_type_code == 3:
                        image_type = "WEBP"
                    else:
-                        logger.info(f"Unknown image type code: ${image_type_code}")
+                        print("Unknown image type code:", image_type_code)
                        return
                    image = Image.open(BytesIO(image_data))
                    # Check if the input ID already exists and replace the input with the new one
@@ -766,14 +552,14 @@ async def websocket_handler(request):
                            if hasattr(existing_image, 'close'):
                                existing_image.close()
                        except Exception as e:
-                            logger.info(f"Error closing previous image for input ID {input_id}: {e}")
+                            print(f"Error closing previous image for input ID {input_id}: {e}")
                    streaming_prompt_metadata[sid].inputs[input_id] = image
                    # clear_current_prompt(sid)
                    # send_prompt(sid, streaming_prompt_metadata[sid])
-                    logger.info(f"Received {image_type} image of size {image.size} with input ID {input_id}")
+                    print(f"Received {image_type} image of size {image.size} with input ID {input_id}")
            if msg.type == aiohttp.WSMsgType.ERROR:
-                logger.info('ws connection closed with exception %s' % ws.exception())
+                print('ws connection closed with exception %s' % ws.exception())
    finally:
        sockets.pop(sid, None)
@@ -818,16 +604,16 @@ async def send(event, data, sid=None):
                if not ws.closed:  # Check if the WebSocket connection is open and not closing
                    await ws.send_json({ 'event': event, 'data': data })
    except Exception as e:
-        logger.info(f"Exception: {e}")
+        print(f"Exception: {e}")
        traceback.print_exc()
-
+logging.basicConfig(level=logging.INFO)
 prompt_server = server.PromptServer.instance
 send_json = prompt_server.send_json
 async def send_json_override(self, event, data, sid=None):
-    # logger.info("INTERNAL:", event, data, sid)
+    # print("INTERNAL:", event, data, sid)
    prompt_id = data.get('prompt_id')
    target_sid = sid
@@ -840,19 +626,8 @@ async def send_json_override(self, event, data, sid=None):
        asyncio.create_task(self.send_json_original(event, data, sid))
    ])
    if prompt_id in comfy_message_queues:
        comfy_message_queues[prompt_id].put_nowait({
            "event": event,
            "data": data
        })
    # event_emitter.emit("send_json", {
    #     "event": event,
    #     "data": data
    # })
    if event == 'execution_start':
-        await update_run(prompt_id, Status.RUNNING)
+        update_run(prompt_id, Status.RUNNING)
        if prompt_id in prompt_metadata:
            prompt_metadata[prompt_id].start_time = time.perf_counter()
@@ -861,12 +636,12 @@ async def send_json_override(self, event, data, sid=None):
    if event == 'executing' and data.get('node') is None:
        mark_prompt_done(prompt_id=prompt_id)
        if not have_pending_upload(prompt_id):
-            await update_run(prompt_id, Status.SUCCESS)
+            update_run(prompt_id, Status.SUCCESS)
            if prompt_id in prompt_metadata:
                current_time = time.perf_counter()
                if prompt_metadata[prompt_id].start_time is not None:
                    elapsed_time = current_time - prompt_metadata[prompt_id].start_time
-                    logger.info(f"Elapsed time: {elapsed_time} seconds")
+                    print(f"Elapsed time: {elapsed_time} seconds")
                    await send("elapsed_time", {
                        "prompt_id": prompt_id,
                        "elapsed_time": elapsed_time
@@ -881,14 +656,13 @@ async def send_json_override(self, event, data, sid=None):
            prompt_metadata[prompt_id].progress.add(node)
            calculated_progress = len(prompt_metadata[prompt_id].progress) / len(prompt_metadata[prompt_id].workflow_api)
-            calculated_progress = round(calculated_progress, 2)
+            # print("calculated_progress", calculated_progress)
            # logger.info("calculated_progress", calculated_progress)
            if prompt_metadata[prompt_id].last_updated_node is not None and prompt_metadata[prompt_id].last_updated_node == node:
                return
            prompt_metadata[prompt_id].last_updated_node = node
            class_type = prompt_metadata[prompt_id].workflow_api[node]['class_type']
-            logger.info(f"At: {calculated_progress * 100}% - {class_type}")
+            print("updating run live status", class_type)
            await send("live_status", {
                "prompt_id": prompt_id,
                "current_node": class_type,
@@ -909,19 +683,18 @@ async def send_json_override(self, event, data, sid=None):
    if event == 'execution_error':
        # Careful this might not be fully awaited.
        await update_run_with_output(prompt_id, data)
-        await update_run(prompt_id, Status.FAILED)
+        update_run(prompt_id, Status.FAILED)
        # await update_run_with_output(prompt_id, data)
    if event == 'executed' and 'node' in data and 'output' in data:
        print("executed", data)
        if prompt_id in prompt_metadata:
            node = data.get('node')
            class_type = prompt_metadata[prompt_id].workflow_api[node]['class_type']
-            logger.info(f"Executed {class_type} {data}")
+            print("executed", class_type)
            if class_type == "PreviewImage":
-                logger.info("Skipping preview image")
+                print("skipping preview image")
                return
        else:
            logger.info(f"Executed {data}")
        await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
        # await update_run_with_output(prompt_id, data.get('output'), node_id=data.get('node'))
@@ -937,34 +710,21 @@ async def update_run_live_status(prompt_id, live_status, calculated_progress: fl
    if prompt_metadata[prompt_id].is_realtime is True:
        return
    print("progress", calculated_progress)
    status_endpoint = prompt_metadata[prompt_id].status_endpoint
    if (status_endpoint is None):
        return
    # logger.info(f"progress {calculated_progress}")
    body = {
        "run_id": prompt_id,
        "live_status": live_status,
        "progress": calculated_progress
    }
    if prompt_id in comfy_message_queues:
        comfy_message_queues[prompt_id].put_nowait({
            "event": "live_status",
            "data": {
                "prompt_id": prompt_id,
                "live_status": live_status,
                "progress": calculated_progress
            }
        })
    # requests.post(status_endpoint, json=body)
-    await async_request_with_retry('POST', status_endpoint, json=body)
+    async with aiohttp.ClientSession() as session:
        async with session.post(status_endpoint, json=body) as response:
            pass
-async def update_run(prompt_id: str, status: Status):
+def update_run(prompt_id: str, status: Status):
    global last_read_line_number
    if prompt_id not in prompt_metadata:
@@ -987,20 +747,18 @@ async def update_run(prompt_id: str, status: Status):
            "run_id": prompt_id,
            "status": status.value,
        }
-        logger.info(f"Status: {status.value}")
+        print(f"Status: {status.value}")
        try:
-            # requests.post(status_endpoint, json=body)
+            requests.post(status_endpoint, json=body)
            if (status_endpoint is not None):
                await async_request_with_retry('POST', status_endpoint, json=body)
-            if (status_endpoint is not None) and cd_enable_run_log and (status == Status.SUCCESS or status == Status.FAILED):
+            if cd_enable_run_log and (status == Status.SUCCESS or status == Status.FAILED):
                try:
                    with open(comfyui_file_path, 'r') as log_file:
                        # log_data = log_file.read()
                        # Move to the last read line
                        all_log_data = log_file.read()  # Read all log data
-                        # logger.info("All log data before skipping: ")  # Log all data before skipping
+                        print("All log data before skipping:", all_log_data)  # Log all data before skipping
                        log_file.seek(0)  # Reset file pointer to the beginning
                        for _ in range(last_read_line_number):
@@ -1008,9 +766,9 @@ async def update_run(prompt_id: str, status: Status):
                        log_data = log_file.read()
                        # Update the last read line number
                        last_read_line_number += log_data.count('\n')
-                        # logger.info("last_read_line_number", last_read_line_number)
+                        print("last_read_line_number", last_read_line_number)
-                        # logger.info("log_data", log_data)
+                        print("log_data", log_data)
-                        # logger.info("log_data.count(n)", log_data.count('\n'))
+                        print("log_data.count(n)", log_data.count('\n'))
                        body = {
                            "run_id": prompt_id,
@@ -1021,26 +779,16 @@ async def update_run(prompt_id: str, status: Status):
                                }
                            ]
                        }
-
+                        requests.post(status_endpoint, json=body)
                        await async_request_with_retry('POST', status_endpoint, json=body)
                        # requests.post(status_endpoint, json=body)
                except Exception as log_error:
-                    logger.info(f"Error reading log file: {log_error}")
+                    print(f"Error reading log file: {log_error}")
        except Exception as e:
            error_type = type(e).__name__
            stack_trace = traceback.format_exc().strip()
-            logger.info(f"Error occurred while updating run: {e} {stack_trace}")
+            print(f"Error occurred while updating run: {e} {stack_trace}")
        finally:
            prompt_metadata[prompt_id].status = status
            if prompt_id in comfy_message_queues:
                comfy_message_queues[prompt_id].put_nowait({
                    "event": "status",
                    "data": {
                        "prompt_id": prompt_id,
                        "status": status.value,
                    }
                })
 async def upload_file(prompt_id, filename, subfolder=None, content_type="image/png", type="output"):
@@ -1058,7 +806,7 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
        output_dir = folder_paths.get_directory_by_type(type)
    if output_dir is None:
-        logger.info(f"{filename} Upload failed: output_dir is None")
+        print(filename, "Upload failed: output_dir is None")
        return 
    if subfolder != None:
@@ -1070,7 +818,7 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
    filename = os.path.basename(filename)
    file = os.path.join(output_dir, filename)
-    logger.info(f"Uploading file {file}")
+    print("uploading file", file)
    file_upload_endpoint = prompt_metadata[prompt_id].file_upload_endpoint
@@ -1083,7 +831,7 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
    start_time = time.time()  # Start timing here
    result = requests.get(target_url)
    end_time = time.time()  # End timing after the request is complete
-    logger.info("Time taken for getting file upload endpoint: {:.2f} seconds".format(end_time - start_time))
+    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
@@ -1096,17 +844,18 @@ async def upload_file(prompt_id, filename, subfolder=None, content_type="image/p
            "Content-Length": str(len(data)),
        }
        # response = requests.put(ok.get("url"), headers=headers, data=data)
-        response = await async_request_with_retry('PUT', ok.get("url"), headers=headers, data=data)
+        async with aiohttp.ClientSession() as session:
-        logger.info(f"Upload file response status: {response.status}, status text: {response.reason}")
+            async with session.put(ok.get("url"), headers=headers, data=data) as response:
-        end_time = time.time()  # End timing after the request is complete
+                print("Upload file response", response.status)
-        logger.info("Upload time: {:.2f} seconds".format(end_time - start_time))
+                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:
-        logger.info(f"Have pending upload {len(prompt_metadata[prompt_id].uploading_nodes)}")
+        print("have pending upload ", len(prompt_metadata[prompt_id].uploading_nodes))
        return True
-    logger.info("No pending upload")
+    print("no pending upload")
    return False
 def mark_prompt_done(prompt_id):
@@ -1118,7 +867,7 @@ def mark_prompt_done(prompt_id):
    """
    if prompt_id in prompt_metadata:
        prompt_metadata[prompt_id].done = True
-        logger.info("Prompt done")
+        print("Prompt done")
 def is_prompt_done(prompt_id: str):
    """
@@ -1150,8 +899,8 @@ async def handle_error(prompt_id, data, e: Exception):
        }
    }
    await update_file_status(prompt_id, data, False, have_error=True)
-    logger.info(body)
+    print(body)
-    logger.info(f"Error occurred while uploading file: {e}")
+    print(f"Error occurred while uploading file: {e}")
 # Mark the current prompt requires upload, and block it from being marked as success
 async def update_file_status(prompt_id: str, data, uploading, have_error=False, node_id=None):
@@ -1164,11 +913,11 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
        else:
            prompt_metadata[prompt_id].uploading_nodes.discard(node_id)
-    logger.info(f"Remaining uploads: {prompt_metadata[prompt_id].uploading_nodes}")
+    print(prompt_metadata[prompt_id].uploading_nodes)
    # Update the remote status
    if have_error:
-        await update_run(prompt_id, Status.FAILED)
+        update_run(prompt_id, Status.FAILED)
        await send("failed", {
            "prompt_id": prompt_id,
        })
@@ -1177,15 +926,15 @@ async def update_file_status(prompt_id: str, data, uploading, have_error=False,
    # if there are still nodes that are uploading, then we set the status to uploading
    if uploading:
        if prompt_metadata[prompt_id].status != Status.UPLOADING:
-            await update_run(prompt_id, Status.UPLOADING)
+            update_run(prompt_id, Status.UPLOADING)
            await send("uploading", {
                "prompt_id": prompt_id,
            })
    # 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):
-        await update_run(prompt_id, Status.SUCCESS)
+        update_run(prompt_id, Status.SUCCESS)
-        # logger.info("Status: SUCCUSS")
+        # print("Status: SUCCUSS")
        await send("success", {
            "prompt_id": prompt_id,
        })
@@ -1248,7 +997,7 @@ async def update_run_with_output(prompt_id, data, node_id=None):
    if have_upload_media:
        try:
-            logger.info(f"\nHave_upload {have_upload_media} Node Id: {node_id}")
+            print("\nhave_upload", have_upload_media, node_id)
            if have_upload_media:
                await update_file_status(prompt_id, data, True, node_id=node_id)
@@ -1259,9 +1008,7 @@ async def update_run_with_output(prompt_id, data, node_id=None):
        except Exception as e:
            await handle_error(prompt_id, data, e)
-    # requests.post(status_endpoint, json=body)
+    requests.post(status_endpoint, json=body)
    if status_endpoint is not None:
        await async_request_with_retry('POST', status_endpoint, json=body)
    await send('outputs_uploaded', {
        "prompt_id": prompt_id
@@ -22,13 +22,12 @@ class StreamingPrompt(BaseModel):
    auth_token: str
    inputs: dict[str, Union[str, bytes, Image.Image]]
    running_prompt_ids: set[str] = set()
-    status_endpoint: Optional[str]
+    status_endpoint: str
-    file_upload_endpoint: Optional[str]
+    file_upload_endpoint: str
 class SimplePrompt(BaseModel):
-    status_endpoint: Optional[str]
+    status_endpoint: str
-    file_upload_endpoint: Optional[str]
+    file_upload_endpoint: str
    workflow_api: dict
    status: Status = Status.NOT_STARTED
    progress: set = set()
@@ -2,4 +2,3 @@ aiofiles
 pydantic
 opencv-python
 imageio-ffmpeg
 # logfire
@@ -13,75 +13,6 @@ function sendEventToCD(event, data) {
  window.parent.postMessage(JSON.stringify(message), "*");
 }
 function dispatchAPIEventData(data) {
  const msg = JSON.parse(data);
  // Custom parse error
  if (msg.error) {
    let message = msg.error.message;
    if (msg.error.details) message += ": " + msg.error.details;
    for (const [nodeID, nodeError] of Object.entries(msg.node_errors)) {
      message += "\n" + nodeError.class_type + ":";
      for (const errorReason of nodeError.errors) {
        message +=
          "\n    - " + errorReason.message + ": " + errorReason.details;
      }
    }
    app.ui.dialog.show(message);
    if (msg.node_errors) {
      app.lastNodeErrors = msg.node_errors;
      app.canvas.draw(true, true);
    }
  }
  switch (msg.event) {
    case "error":
      break;
    case "status":
      if (msg.data.sid) {
        // this.clientId = msg.data.sid;
        // window.name = this.clientId; // use window name so it isnt reused when duplicating tabs
        // sessionStorage.setItem("clientId", this.clientId); // store in session storage so duplicate tab can load correct workflow
      }
      api.dispatchEvent(new CustomEvent("status", { detail: msg.data.status }));
      break;
    case "progress":
      api.dispatchEvent(new CustomEvent("progress", { detail: msg.data }));
      break;
    case "executing":
      api.dispatchEvent(
        new CustomEvent("executing", { detail: msg.data.node }),
      );
      break;
    case "executed":
      api.dispatchEvent(new CustomEvent("executed", { detail: msg.data }));
      break;
    case "execution_start":
      api.dispatchEvent(
        new CustomEvent("execution_start", { detail: msg.data }),
      );
      break;
    case "execution_error":
      api.dispatchEvent(
        new CustomEvent("execution_error", { detail: msg.data }),
      );
      break;
    case "execution_cached":
      api.dispatchEvent(
        new CustomEvent("execution_cached", { detail: msg.data }),
      );
      break;
    default:
      api.dispatchEvent(new CustomEvent(msg.type, { detail: msg.data }));
    // default:
    // if (this.#registered.has(msg.type)) {
    // } else {
    // throw new Error(`Unknown message type ${msg.type}`);
    // }
  }
 }
 /** @typedef {import('../../../web/types/comfy.js').ComfyExtension} ComfyExtension*/
 /** @type {ComfyExtension} */
 const ext = {
@@ -102,10 +33,11 @@ const ext = {
      sendEventToCD("cd_plugin_onInit");
-      app.queuePrompt = ((originalFunction) => async () => {
+      app.queuePrompt = ((originalFunction) =>
-        // const prompt = await app.graphToPrompt();
+        async () => {
-        sendEventToCD("cd_plugin_onQueuePromptTrigger");
+          // const prompt = await app.graphToPrompt();
-      })(app.queuePrompt);
+          sendEventToCD("cd_plugin_onQueuePromptTrigger");
        })(app.queuePrompt);
      // // Intercept the onkeydown event
      // window.addEventListener(
@@ -258,56 +190,32 @@ const ext = {
    // const graphCanvas = document.getElementById("graph-canvas");
    window.addEventListener("message", async (event) => {
      //   console.log("message", event);
      try {
        const message = JSON.parse(event.data);
        if (message.type === "graph_load") {
          const comfyUIWorkflow = message.data;
-          // console.log("recieved: ", comfyUIWorkflow);
+          console.log("recieved: ", comfyUIWorkflow);
          // Assuming there's a method to load the workflow data into the ComfyUI
          // This part of the code would depend on how the ComfyUI expects to receive and process the workflow data
          // For demonstration, let's assume there's a loadWorkflow method in the ComfyUI API
          if (comfyUIWorkflow && app && app.loadGraphData) {
            console.log("loadGraphData");
            app.loadGraphData(comfyUIWorkflow);
          }
        } else if (message.type === "deploy") {
          // deployWorkflow();
          const prompt = await app.graphToPrompt();
          // api.handlePromptGenerated(prompt);
          sendEventToCD("cd_plugin_onDeployChanges", prompt);
        } else if (message.type === "queue_prompt") {
          const prompt = await app.graphToPrompt();
          api.handlePromptGenerated(prompt);
          sendEventToCD("cd_plugin_onQueuePrompt", prompt);
        } else if (message.type === "get_prompt") {
          const prompt = await app.graphToPrompt();
          sendEventToCD("cd_plugin_onGetPrompt", prompt);
        } else if (message.type === "event") {
          dispatchAPIEventData(message.data);
        } else if (message.type === "add_node") {
          console.log("add node", message.data);
          app.graph.beforeChange();
          var node = LiteGraph.createNode(message.data.type);
          node.configure({
            widgets_values: message.data.widgets_values,
          });
          console.log("node", node);
          const graphMouse = app.canvas.graph_mouse;
          node.pos = [graphMouse[0], graphMouse[1]];
          app.graph.add(node);
          app.graph.afterChange();
        }
        // else if (message.type === "refresh") {
        //   sendEventToCD("cd_plugin_onRefresh");
        // }
      } catch (error) {
        // console.error("Error processing message:", error);
      }
      // if (!event.data.flow || Object.entries(event.data.flow).length <= 0)
      //   return;
      //   updateBlendshapesPrompts(event.data.flow);
    });
    api.addEventListener("executed", (evt) => {
@@ -364,10 +272,10 @@ function createDynamicUIHtml(data) {
          <h3 style="font-size: 14px; font-weight: semibold; margin-bottom: 8px;">Missing Nodes</h3>
          <p style="font-size: 12px;">These nodes are not found with any matching custom_nodes in the ComfyUI Manager Database</p>
          ${data.missing_nodes
-        .map((node) => {
+            .map((node) => {
-          return `<p style="font-size: 14px; color: #d69e2e;">${node}</p>`;
+              return `<p style="font-size: 14px; color: #d69e2e;">${node}</p>`;
-        })
+            })
-        .join("")}
+            .join("")}
      </div>
  `;
  }
@@ -375,14 +283,17 @@ function createDynamicUIHtml(data) {
  Object.values(data.custom_nodes).forEach((node) => {
    html += `
          <div style="border-bottom: 1px solid #e2e8f0; padding-top: 16px;">
-              <a href="${node.url
+              <a href="${
-      }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${node.name
+                node.url
-      }</a>
+              }" target="_blank" style="font-size: 18px; font-weight: semibold; color: white; text-decoration: none;">${
                node.name
              }</a>
              <p style="font-size: 14px; color: #4b5563;">${node.hash}</p>
-              ${node.warning
+              ${
-        ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
+                node.warning
-        : ""
+                  ? `<p style="font-size: 14px; color: #d69e2e;">${node.warning}</p>`
-      }
+                  : ""
              }
          </div>
      `;
  });
@@ -396,8 +307,9 @@ function createDynamicUIHtml(data) {
  Object.entries(data.models).forEach(([section, items]) => {
    html += `
    <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
-      }</h3>`;
+          section.charAt(0).toUpperCase() + section.slice(1)
        }</h3>`;
    items.forEach((item) => {
      html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
    });
@@ -413,8 +325,9 @@ function createDynamicUIHtml(data) {
  Object.entries(data.files).forEach(([section, items]) => {
    html += `
    <div style="border-bottom: 1px solid #e2e8f0; padding-top: 8px; padding-bottom: 8px;">
-        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${section.charAt(0).toUpperCase() + section.slice(1)
+        <h3 style="font-size: 18px; font-weight: semibold; margin-bottom: 8px;">${
-      }</h3>`;
+          section.charAt(0).toUpperCase() + section.slice(1)
        }</h3>`;
    items.forEach((item) => {
      html += `<p style="font-size: 14px; color: ${textColor};">${item.name}</p>`;
    });
@@ -837,12 +750,14 @@ export class LoadingDialog extends ComfyDialog {
  showLoading(title, message) {
    this.show(`
      <div style="width: 400px; display: flex; gap: 18px; flex-direction: column; overflow: unset">
-        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${this.loadingIcon
+        <h3 style="margin: 0px; display: flex; align-items: center; justify-content: center; gap: 12px;">${title} ${
-      }</h3>
+          this.loadingIcon
-          ${message
+        }</h3>
-        ? `<label style="max-width: 100%; white-space: pre-wrap; word-wrap: break-word;">${message}</label>`
+          ${
-        : ""
+            message
-      }
+              ? `<label style="max-width: 100%; white-space: pre-wrap; word-wrap: break-word;">${message}</label>`
              : ""
          }
        </div>
      `);
  }
@@ -1108,17 +1023,21 @@ export class ConfigDialog extends ComfyDialog {
    </label>
      <label style="color: white; width: 100%;">
        Endpoint:
-        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${data.endpoint
+        <input id="endpoint" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="text" value="${
-      }">
+          data.endpoint
        }">
      </label>
      <div style="color: white;">
-        API Key: User / Org <button style="font-size: 18px;">${data.displayName ?? ""
+        API Key: User / Org <button style="font-size: 18px;">${
-      }</button>
+          data.displayName ?? ""
-        <input id="apiKey" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="password" value="${data.apiKey
+        }</button>
-      }">
+        <input id="apiKey" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;" type="password" value="${
          data.apiKey
        }">
        <button id="loginButton" style="margin-top: 8px; width: 100%; height:40px; box-sizing: border-box; padding: 0px 6px;">
-          ${data.apiKey ? "Re-login with ComfyDeploy" : "Login with ComfyDeploy"
+          ${
-      }
+            data.apiKey ? "Re-login with ComfyDeploy" : "Login with ComfyDeploy"
          }
        </button>
      </div>
      </div>
@@ -74,7 +74,7 @@
    "mitata": "^0.1.6",
    "ms": "^2.1.3",
    "nanoid": "^5.0.4",
-    "next": "14.2",
+    "next": "14.1",
    "next-plausible": "^3.12.0",
    "next-themes": "^0.2.1",
    "next-usequerystate": "^1.13.2",
@@ -102,7 +102,7 @@ export const createRun = withServerPromise(
    let prompt_id: string | undefined = undefined;
    const shareData = {
-      workflow_api_raw: workflow_api,
+      workflow_api: workflow_api,
      status_endpoint: `${origin}/api/update-run`,
      file_upload_endpoint: `${origin}/api/file-upload`,
    };