openapi: add type enum to Workspace schema (cutover follow-up)

Cloud's Workspace runtime shape includes a 'type' field with enum
[personal, team] that vendor's Workspace was missing. Cloud handlers
reference the generated ingest.WorkspaceType Go enum.

Same kind of surgical addition as JobEntry.status / BillingStatus /
JobDetailResponse.status in this PR — adds cloud-runtime field to
existing vendor schema.

README.md

@@ -433,7 +433,7 @@ See also: [https://www.comfy.org/](https://www.comfy.org/)
 
 ## Frontend Development
 
-As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). The compiled JS files (from TS/Vue) are published to [pypi](https://pypi.org/project/comfyui-frontend-package) and installed as a dependency in ComfyUI.
+As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). This repository now hosts the compiled JS (from TS/Vue) under the `web/` directory.
 
 ### Reporting Issues and Requesting Features
 

app/logger.py

@@ -5,40 +5,6 @@ import logging
 import sys
 import threading
 
-ANSI_NAMED_COLORS = {
-    'black':   '\033[30m',
-    'red':     '\033[31m',
-    'green':   '\033[32m',
-    'yellow':  '\033[33m',
-    'blue':    '\033[34m',
-    'magenta': '\033[35m',
-    'cyan':    '\033[36m',
-    'white':   '\033[37m',
-}
-
-ANSI_LEVEL_COLORS = {
-    'DEBUG':    ANSI_NAMED_COLORS['cyan'],
-    'INFO':     ANSI_NAMED_COLORS['green'],
-    'WARNING':  ANSI_NAMED_COLORS['yellow'],
-    'ERROR':    ANSI_NAMED_COLORS['red'],
-    'CRITICAL': ANSI_NAMED_COLORS['magenta'],
-}
-
-ANSI_RESET = '\033[0m'
-ANSI_BOLD  = '\033[1m'
-
-
-class ColoredFormatter(logging.Formatter):
-    def format(self, record):
-        color = ANSI_LEVEL_COLORS.get(record.levelname, '')
-        bold  = ANSI_BOLD if record.levelno >= logging.WARNING else ''
-        level_tag = f"{bold}{color}[{record.levelname}]{ANSI_RESET} "
-        message = super().format(record)
-        line_color = ANSI_NAMED_COLORS.get(getattr(record, 'color', ''), '')
-        if line_color:
-            return f"{level_tag}{line_color}{message}{ANSI_RESET}"
-        return level_tag + message
-
 logs = None
 stdout_interceptor = None
 stderr_interceptor = None
@@ -102,10 +68,8 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
     logger = logging.getLogger()
     logger.setLevel(log_level)
 
-    formatter = ColoredFormatter("%(message)s")
-
     stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(formatter)
+    stream_handler.setFormatter(logging.Formatter("%(message)s"))
 
     if use_stdout:
         # Only errors and critical to stderr
@@ -113,7 +77,7 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
 
         # Lesser to stdout
         stdout_handler = logging.StreamHandler(sys.stdout)
-        stdout_handler.setFormatter(formatter)
+        stdout_handler.setFormatter(logging.Formatter("%(message)s"))
         stdout_handler.addFilter(lambda record: record.levelno < logging.ERROR)
         logger.addHandler(stdout_handler)
 

comfy/cli_args.py

@@ -111,7 +111,7 @@ parser.add_argument("--preview-method", type=LatentPreviewMethod, default=Latent
 parser.add_argument("--preview-size", type=int, default=512, help="Sets the maximum preview size for sampler nodes.")
 
 cache_group = parser.add_mutually_exclusive_group()
-cache_group.add_argument("--cache-ram", nargs='*', type=float, default=[], metavar="GB", help="Use RAM pressure caching with the specified headroom thresholds. This is the default caching mode. The first value sets the active-cache threshold; the optional second value sets the inactive-cache/pin threshold. Defaults when no values are provided: active 10%% of system RAM (min 2GB, max 10GB), inactive 100%% of system RAM (max 96GB).")
+cache_group.add_argument("--cache-ram", nargs='*', type=float, default=[], metavar="GB", help="Use RAM pressure caching with the specified headroom thresholds. This is the default caching mode. The first value sets the active-cache threshold; the optional second value sets the inactive-cache/pin threshold. Defaults when no values are provided: active 25%% of system RAM (min 4GB, max 32GB), inactive 75%% of system RAM (min 12GB, max 96GB).")
 cache_group.add_argument("--cache-classic", action="store_true", help="Use the old style (aggressive) caching.")
 cache_group.add_argument("--cache-lru", type=int, default=0, help="Use LRU caching with a maximum of N node results cached. May use more RAM/VRAM.")
 cache_group.add_argument("--cache-none", action="store_true", help="Reduced RAM/VRAM usage at the expense of executing every node for each run.")

comfy/ldm/modules/attention.py

@@ -741,12 +741,12 @@ optimized_attention = attention_basic
 if model_management.sage_attention_enabled():
     logging.info("Using sage attention")
     optimized_attention = attention_sage
-elif model_management.flash_attention_enabled():
-    logging.info("Using Flash Attention")
-    optimized_attention = attention_flash
 elif model_management.xformers_enabled():
     logging.info("Using xformers attention")
     optimized_attention = attention_xformers
+elif model_management.flash_attention_enabled():
+    logging.info("Using Flash Attention")
+    optimized_attention = attention_flash
 elif model_management.pytorch_attention_enabled():
     logging.info("Using pytorch attention")
     optimized_attention = attention_pytorch

comfy/model_management.py

@@ -1217,7 +1217,7 @@ def get_aimdo_cast_buffer(offload_stream, device):
 def get_pin_buffer(offload_stream):
     pin_buffer = STREAM_PIN_BUFFERS.get(offload_stream, None)
     if pin_buffer is None:
-        pin_buffer = comfy_aimdo.host_buffer.HostBuffer(0, 0, pinned_hostbuf_size(8 * 1024**3), mark_cold=False)
+        pin_buffer = comfy_aimdo.host_buffer.HostBuffer(0, 0, pinned_hostbuf_size(8 * 1024**3))
         STREAM_PIN_BUFFERS[offload_stream] = pin_buffer
     elif offload_stream is not None:
         event = getattr(pin_buffer, "_comfy_event", None)

comfy/samplers.py

@@ -265,6 +265,7 @@ def _calc_cond_batch(model: BaseModel, conds: list[list[dict]], x_in: torch.Tens
                 input_shape = [len(batch_amount) * first_shape[0]] + list(first_shape)[1:]
                 cond_shapes = collections.defaultdict(list)
                 for tt in batch_amount:
+                    cond = {k: v.size() for k, v in to_run[tt][0].conditioning.items()}
                     for k, v in to_run[tt][0].conditioning.items():
                         cond_shapes[k].append(v.size())
 

comfy_api_nodes/apis/bytedance.py

@@ -158,9 +158,8 @@ class SeedanceCreateAssetResponse(BaseModel):
 
 
 class SeedanceVirtualLibraryCreateAssetRequest(BaseModel):
-    url: str = Field(..., description="Publicly accessible URL of the asset to upload.")
+    url: str = Field(..., description="Publicly accessible URL of the image asset to upload.")
     hash: str = Field(..., description="Dedup key. Re-submitting the same hash returns the existing asset id.")
-    asset_type: str | None = Field(None, description="BytePlus asset type. Defaults to Image server-side when omitted.")
 
 
 # Dollars per 1K tokens, keyed by (model_id, has_video_input).

comfy_api_nodes/nodes_bytedance.py

@@ -2,12 +2,11 @@ import hashlib
 import logging
 import math
 import re
-from io import BytesIO
 
 import torch
 from typing_extensions import override
 
-from comfy_api.latest import IO, ComfyExtension, Input, Types
+from comfy_api.latest import IO, ComfyExtension, Input
 from comfy_api_nodes.apis.bytedance import (
     RECOMMENDED_PRESETS,
     RECOMMENDED_PRESETS_SEEDREAM_4,
@@ -309,26 +308,6 @@ async def _seedance_virtual_library_upload_image_asset(
     return f"asset://{create_resp.asset_id}"
 
 
-async def _seedance_virtual_library_upload_video_asset(
-    cls: type[IO.ComfyNode],
-    video: Input.Video,
-    *,
-    wait_label: str = "Uploading video",
-) -> str:
-    buf = BytesIO()
-    video.save_to(buf, format=Types.VideoContainer.MP4, codec=Types.VideoCodec.H264)
-    video_hash = hashlib.sha256(buf.getbuffer()).hexdigest()
-    public_url = await upload_video_to_comfyapi(cls, video, wait_label=wait_label)
-    create_resp = await sync_op(
-        cls,
-        ApiEndpoint(path="/proxy/seedance/virtual-library/assets", method="POST"),
-        response_model=SeedanceCreateAssetResponse,
-        data=SeedanceVirtualLibraryCreateAssetRequest(url=public_url, hash=video_hash, asset_type="Video"),
-    )
-    await _wait_for_asset_active(cls, create_resp.asset_id, group_id="virtual-library")
-    return f"asset://{create_resp.asset_id}"
-
-
 def _seedance2_price_extractor(model_id: str, has_video_input: bool):
     """Returns a price_extractor closure for Seedance 2.0 poll_op."""
     rate = SEEDANCE2_PRICE_PER_1K_TOKENS.get((model_id, has_video_input))
@@ -2127,7 +2106,7 @@ class ByteDance2ReferenceNode(IO.ComfyNode):
             content.append(
                 TaskVideoContent(
                     video_url=TaskVideoContentUrl(
-                        url=await _seedance_virtual_library_upload_video_asset(
+                        url=await upload_video_to_comfyapi(
                             cls,
                             reference_videos[key],
                             wait_label=f"Uploading video {i}",

comfy_extras/nodes_images.py

@@ -3,23 +3,15 @@ from __future__ import annotations
 import nodes
 import folder_paths
 
-import av
 import json
-
 import os
 import re
 import math
-import numpy as np
-import struct
 import torch
-
-import zlib
 import comfy.utils
-from fractions import Fraction
 
 from server import PromptServer
 from comfy_api.latest import ComfyExtension, IO, UI
-from comfy.cli_args import args
 from typing_extensions import override
 
 SVG = IO.SVG.Type  # TODO: temporary solution for backward compatibility, will be removed later.
@@ -843,405 +835,6 @@ class ImageMergeTileList(IO.ComfyNode):
         return IO.NodeOutput(merged_image)
 
 
-# ---------------------------------------------------------------------------
-# Format specifications
-# ---------------------------------------------------------------------------
-
-# Maps (file_format, bit_depth, has_alpha) -> (numpy dtype scale, av pixel format,
-# stream pix_fmt). Keeps the encode path declarative instead of branchy.
-_FORMAT_SPECS = {
-    ("png", "8-bit", False):  {"scale": 255.0,   "dtype": np.uint8,   "frame_fmt": "rgb24",     "stream_fmt": "rgb24"},
-    ("png", "8-bit", True):   {"scale": 255.0,   "dtype": np.uint8,   "frame_fmt": "rgba",      "stream_fmt": "rgba"},
-    ("png", "16-bit", False): {"scale": 65535.0, "dtype": np.uint16,  "frame_fmt": "rgb48le",   "stream_fmt": "rgb48be"},
-    ("png", "16-bit", True):  {"scale": 65535.0, "dtype": np.uint16,  "frame_fmt": "rgba64le",  "stream_fmt": "rgba64be"},
-    ("exr", "32-bit float", False): {"scale": 1.0, "dtype": np.float32, "frame_fmt": "gbrpf32le",  "stream_fmt": "gbrpf32le"},
-    ("exr", "32-bit float", True):  {"scale": 1.0, "dtype": np.float32, "frame_fmt": "gbrapf32le", "stream_fmt": "gbrapf32le"},
-}
-
-
-# ---------------------------------------------------------------------------
-# Color transforms
-# ---------------------------------------------------------------------------
-
-def srgb_to_linear(t: torch.Tensor) -> torch.Tensor:
-    """Inverse sRGB EOTF (IEC 61966-2-1). Operates on RGB channels only;
-    alpha (if present as the 4th channel) is passed through unchanged."""
-    if t.shape[-1] == 4:
-        rgb, alpha = t[..., :3], t[..., 3:]
-        return torch.cat([srgb_to_linear(rgb), alpha], dim=-1)
-
-    # Piecewise: linear toe below 0.04045, gamma curve above.
-    low = t / 12.92
-    high = ((t.clamp(min=0.0) + 0.055) / 1.055) ** 2.4
-    return torch.where(t <= 0.04045, low, high)
-
-
-# HLG OETF constants from BT.2100 Table 5.
-_HLG_A = 0.17883277
-_HLG_B = 0.28466892
-_HLG_C = 0.55991072928   # = 0.5 - a*ln(4*a)
-
-
-def hlg_to_linear(t: torch.Tensor) -> torch.Tensor:
-    """Inverse HLG OETF (BT.2100). Maps a non-linear HLG signal in [0, 1] to
-    *scene*-linear light in [0, 1]. Per BT.2100 Note 5a, this is the correct
-    transform when converting HLG to a linear scene-light representation
-    (rather than display-light, which would also involve the HLG OOTF).
-
-    Operates on RGB channels only; alpha is passed through unchanged."""
-    if t.shape[-1] == 4:
-        rgb, alpha = t[..., :3], t[..., 3:]
-        return torch.cat([hlg_to_linear(rgb), alpha], dim=-1)
-
-    # Piecewise: sqrt branch below 0.5, log branch above.
-    # Clamp inside the log branch so negative / out-of-range values don't blow up;
-    # values above 1.0 are allowed and extrapolate naturally.
-    low = (t ** 2) / 3.0
-    high = (torch.exp((t.clamp(min=_HLG_C) - _HLG_C) / _HLG_A) + _HLG_B) / 12.0
-    return torch.where(t <= 0.5, low, high)
-
-
-# ---------------------------------------------------------------------------
-# Metadata injection
-# ---------------------------------------------------------------------------
-
-_PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
-
-
-def _png_chunk(chunk_type: bytes, data: bytes) -> bytes:
-    """Build a single PNG chunk: length | type | data | CRC32(type+data)."""
-    crc = zlib.crc32(chunk_type + data) & 0xFFFFFFFF
-    return struct.pack(">I", len(data)) + chunk_type + data + struct.pack(">I", crc)
-
-
-def _png_text_chunk(keyword: str, text: str) -> bytes:
-    """tEXt chunk: latin-1 keyword + NUL + latin-1 text."""
-    payload = keyword.encode("latin-1") + b"\x00" + text.encode("latin-1", errors="replace")
-    return _png_chunk(b"tEXt", payload)
-
-
-def inject_png_metadata(png_bytes: bytes, prompt: dict | None, extra_pnginfo: dict | None) -> bytes:
-    """Insert ComfyUI prompt/workflow as tEXt chunks right after IHDR."""
-    if not png_bytes.startswith(_PNG_SIGNATURE):
-        return png_bytes
-
-    chunks: list[bytes] = []
-    if prompt is not None:
-        chunks.append(_png_text_chunk("prompt", json.dumps(prompt)))
-    if extra_pnginfo:
-        for key, value in extra_pnginfo.items():
-            chunks.append(_png_text_chunk(key, json.dumps(value)))
-    if not chunks:
-        return png_bytes
-
-    # IHDR is always the first chunk; insert ours immediately after it.
-    ihdr_length = struct.unpack(">I", png_bytes[8:12])[0]
-    ihdr_end = 8 + 8 + ihdr_length + 4  # signature + (len+type) + data + crc
-    return png_bytes[:ihdr_end] + b"".join(chunks) + png_bytes[ihdr_end:]
-
-
-# Standard chromaticities (CIE 1931 xy) for the colorspaces this node writes.
-# Each tuple is (Rx, Ry, Gx, Gy, Bx, By, Wx, Wy). All share D65 white point.
-_CHROMATICITIES = {
-    # ITU-R BT.709 / sRGB primaries
-    "Rec.709":  (0.6400, 0.3300, 0.3000, 0.6000, 0.1500, 0.0600, 0.3127, 0.3290),
-    # ITU-R BT.2020 (UHDTV / wide-gamut HDR) primaries
-    "Rec.2020": (0.7080, 0.2920, 0.1700, 0.7970, 0.1310, 0.0460, 0.3127, 0.3290),
-}
-
-
-def _pack_chromaticities(primaries: tuple) -> bytes:
-    """Serialize 8 chromaticity floats into the EXR `chromaticities` payload."""
-    return struct.pack("<8f", *primaries)
-
-
-def _exr_attribute(name: str, attr_type: str, value: bytes) -> bytes:
-    """Serialize one EXR header attribute: name\\0 type\\0 size:int32 value."""
-    return (
-        name.encode("utf-8") + b"\x00"
-        + attr_type.encode("utf-8") + b"\x00"
-        + struct.pack("<i", len(value))
-        + value
-    )
-
-
-def inject_exr_metadata(
-    exr_bytes: bytes,
-    prompt: dict | None,
-    extra_pnginfo: dict | None,
-    colorspace: str | None = None,
-) -> bytes:
-    """Insert ComfyUI metadata and color-space info into an EXR header.
-
-    Color: EXR pixels are linear by convention. The standard way to describe
-    their RGB→XYZ relationship is the `chromaticities` attribute. We pick the
-    primaries that match what the user told us their input was:
-
-      colorspace="sRGB" → Rec. 709 / sRGB primaries (D65)
-      colorspace="HDR"  → Rec. 2020 / BT.2100 primaries (D65)
-
-    Pixels are always converted to linear scene light upstream (sRGB EOTF
-    inverse for sRGB; HLG OETF inverse for HDR), so the file content is
-    scene-linear in the indicated gamut. OpenEXR has no standard transfer-
-    function attribute (the OpenEXR TSC has discussed adding one but it
-    doesn't exist), so we don't invent one — `chromaticities` plus the EXR
-    linear-by-convention rule fully specifies the color.
-
-    Prompt/workflow: written as plain `string` attributes using the same keys
-    (`prompt`, `workflow`, ...) that Comfy uses for PNG tEXt chunks, so the
-    same readers can pull them out symmetrically.
-
-    Implementation note: the chunk-offset table that follows the header stores
-    *absolute* byte offsets into the file. Inserting N bytes into the header
-    means every offset must be incremented by N or the file becomes unreadable.
-    """
-    if len(exr_bytes) < 8 or exr_bytes[:4] != b"\x76\x2f\x31\x01":
-        return exr_bytes
-
-    new_blob = b""
-    if prompt is not None:
-        new_blob += _exr_attribute("prompt", "string", json.dumps(prompt).encode("utf-8"))
-    if extra_pnginfo:
-        for key, value in extra_pnginfo.items():
-            new_blob += _exr_attribute(key, "string", json.dumps(value).encode("utf-8"))
-    if colorspace is not None:
-        # Map each colorspace option to the RGB primaries the linear pixels
-        # are now in. "sRGB" and "linear" both produce Rec. 709 linear; "HDR"
-        # (HLG-encoded Rec. 2020 input) produces Rec. 2020 linear.
-        primaries_name = {
-            "sRGB":   "Rec.709",
-            "linear": "Rec.709",
-            "HDR":    "Rec.2020",
-        }.get(colorspace, "Rec.709")
-        new_blob += _exr_attribute(
-            "chromaticities",
-            "chromaticities",
-            _pack_chromaticities(_CHROMATICITIES[primaries_name]),
-        )
-    if not new_blob:
-        return exr_bytes
-
-    # Walk header attributes to find the terminating null byte, and pick up
-    # dataWindow + compression so we know how many chunks the offset table has.
-    pos = 8  # past magic (4) + version (4)
-    data_window = None
-    compression = 0
-    while pos < len(exr_bytes) and exr_bytes[pos] != 0:
-        name_end = exr_bytes.index(b"\x00", pos)
-        attr_name = exr_bytes[pos:name_end].decode("latin-1", errors="replace")
-        type_end = exr_bytes.index(b"\x00", name_end + 1)
-        attr_type = exr_bytes[name_end + 1:type_end].decode("latin-1", errors="replace")
-        size = struct.unpack("<i", exr_bytes[type_end + 1:type_end + 5])[0]
-        value_start = type_end + 5
-        value = exr_bytes[value_start:value_start + size]
-
-        if attr_name == "dataWindow" and attr_type == "box2i":
-            data_window = struct.unpack("<iiii", value)  # xMin, yMin, xMax, yMax
-        elif attr_name == "compression" and attr_type == "compression":
-            compression = value[0]
-
-        pos = value_start + size
-
-    if data_window is None:
-        return exr_bytes  # required attribute missing — don't risk corrupting
-
-    # Scanlines per chunk by compression, from the OpenEXR spec.
-    scanlines_per_block = {
-        0: 1,   # NO_COMPRESSION
-        1: 1,   # RLE
-        2: 1,   # ZIPS
-        3: 16,  # ZIP
-        4: 32,  # PIZ
-        5: 16,  # PXR24
-        6: 32,  # B44
-        7: 32,  # B44A
-        8: 256, # DWAA
-        9: 256, # DWAB
-    }.get(compression, 1)
-
-    _, y_min, _, y_max = data_window
-    height = y_max - y_min + 1
-    num_chunks = (height + scanlines_per_block - 1) // scanlines_per_block
-
-    header_end = pos  # position of the terminating null byte
-    table_start = header_end + 1
-    pixel_start = table_start + num_chunks * 8
-    delta = len(new_blob)
-
-    old_offsets = struct.unpack(f"<{num_chunks}Q", exr_bytes[table_start:pixel_start])
-    new_table = struct.pack(f"<{num_chunks}Q", *(o + delta for o in old_offsets))
-
-    return (
-        exr_bytes[:header_end]                # header attributes
-        + new_blob                            # our new attributes
-        + exr_bytes[header_end:table_start]   # terminating null byte
-        + new_table                           # shifted offset table
-        + exr_bytes[pixel_start:]             # pixel data, untouched
-    )
-
-
-# ---------------------------------------------------------------------------
-# Encoding
-# ---------------------------------------------------------------------------
-
-def _encode_image(
-    img_tensor: torch.Tensor,
-    file_format: str,
-    bit_depth: str,
-    colorspace: str,
-) -> bytes:
-    """Encode a single HxWxC tensor to PNG or EXR bytes in memory.
-
-    For EXR the input is interpreted according to `colorspace` and converted
-    to scene-linear (EXR's convention) before writing:
-
-      "sRGB"   → input is sRGB-encoded Rec. 709; apply inverse sRGB EOTF.
-      "HDR"    → input is HLG-encoded Rec. 2020 (BT.2100); apply inverse HLG
-                 OETF to get scene-linear, per BT.2100 Note 5a.
-      "linear" → input is already scene-linear (Rec. 709 primaries); write
-                 through unchanged. Use this for renderer/compositor output.
-
-    For PNG, colorspace selection does not modify pixels — PNG is delivered
-    sRGB-encoded and there is no PNG path for wide-gamut HDR in this node.
-    """
-    height, width, num_channels = img_tensor.shape
-    has_alpha = num_channels == 4
-
-    spec = _FORMAT_SPECS[(file_format, bit_depth, has_alpha)]
-
-    if spec["dtype"] == np.float32:
-        # EXR path: preserve full range, no clamp.
-        if colorspace == "sRGB":
-            img_tensor = srgb_to_linear(img_tensor)
-        elif colorspace == "HDR":
-            img_tensor = hlg_to_linear(img_tensor)
-        img_np = img_tensor.cpu().numpy().astype(np.float32)
-    else:
-        # PNG path: quantize to integer range.
-        scaled = (img_tensor * spec["scale"]).clamp(0, spec["scale"])
-        img_np = scaled.to(torch.int32).cpu().numpy().astype(spec["dtype"])
-
-    # Encode directly via CodecContext. PyAV's `image2` muxer does NOT write to
-    # BytesIO (it expects a real file path), so we bypass the container entirely.
-    # For single-frame PNG/EXR the raw codec output IS the file.
-    codec = av.CodecContext.create(file_format, "w")
-    codec.width = width
-    codec.height = height
-    codec.pix_fmt = spec["stream_fmt"]
-    codec.time_base = Fraction(1, 1)
-
-    frame = av.VideoFrame.from_ndarray(img_np, format=spec["frame_fmt"])
-    if spec["frame_fmt"] != spec["stream_fmt"]:
-        frame = frame.reformat(format=spec["stream_fmt"])
-    frame.pts = 0
-    frame.time_base = codec.time_base
-
-    packets = list(codec.encode(frame)) + list(codec.encode(None))  # flush with None
-    return b"".join(bytes(p) for p in packets)
-
-
-# ---------------------------------------------------------------------------
-# Node
-# ---------------------------------------------------------------------------
-
-class SaveImageAdvanced(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="SaveImageAdvanced",
-            search_aliases=["save", "save image", "export image", "output image", "write image"],
-            display_name="Save Image (Advanced)",
-            description="Saves the input images to your ComfyUI output directory.",
-            category="image",
-            essentials_category="Basics",
-            inputs=[
-                IO.Image.Input("images", tooltip="The images to save."),
-                IO.String.Input(
-                    "filename_prefix",
-                    default="ComfyUI",
-                    tooltip=(
-                        "The prefix for the file to save. May include formatting tokens "
-                        "such as %date:yyyy-MM-dd% or %Empty Latent Image.width%."
-                    ),
-                ),
-                IO.DynamicCombo.Input(
-                    "format",
-                    options=[
-                        IO.DynamicCombo.Option("png", [
-                            IO.Combo.Input("bit_depth", options=["8-bit", "16-bit"],
-                                           default="8-bit", advanced=True),
-                            IO.Combo.Input("input_color_space", options=["sRGB"],
-                                           default="sRGB", advanced=True),
-                        ]),
-                        IO.DynamicCombo.Option("exr", [
-                            IO.Combo.Input("bit_depth", options=["32-bit float"],
-                                           default="32-bit float", advanced=True),
-                            IO.Combo.Input(
-                                "input_color_space",
-                                options=["sRGB", "HDR", "linear"],
-                                default="sRGB",
-                                advanced=True,
-                                tooltip=(
-                                    "Colorspace of the input tensor. The EXR is "
-                                    "always written as scene-linear in the matching "
-                                    "gamut.\n"
-                                    "  'sRGB'   — input is sRGB-encoded Rec.709; "
-                                    "the inverse sRGB EOTF is applied.\n"
-                                    "  'HDR'    — input is HLG-encoded Rec.2020 "
-                                    "(BT.2100); the inverse HLG OETF is applied "
-                                    "to get scene-linear light.\n"
-                                    "  'linear' — input is already scene-linear "
-                                    "(Rec.709 primaries); written through unchanged. "
-                                    "Use this for renderer/compositor output."
-                                ),
-                            ),
-                        ]),
-                    ],
-                    tooltip="The file format in which to save the image.",
-                ),
-            ],
-            hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],
-            is_output_node=True,
-        )
-
-    @classmethod
-    def execute(cls, images, filename_prefix: str, format: dict) -> IO.NodeOutput:
-        file_format = format["format"]
-        bit_depth = format["bit_depth"]
-        colorspace = format.get("input_color_space", "sRGB")
-
-        output_dir = folder_paths.get_output_directory()
-        full_output_folder, filename, counter, subfolder, filename_prefix = (
-            folder_paths.get_save_image_path(
-                filename_prefix, output_dir, images[0].shape[1], images[0].shape[0]
-            )
-        )
-
-        prompt = cls.hidden.prompt
-        extra_pnginfo = cls.hidden.extra_pnginfo
-        write_metadata = not args.disable_metadata
-
-        results = []
-        for batch_number, image in enumerate(images):
-            encoded = _encode_image(image, file_format, bit_depth, colorspace)
-
-            if write_metadata:
-                if file_format == "png":
-                    encoded = inject_png_metadata(encoded, prompt, extra_pnginfo)
-                elif file_format == "exr":
-                    encoded = inject_exr_metadata(encoded, prompt, extra_pnginfo, colorspace)
-
-            name = filename.replace("%batch_num%", str(batch_number))
-            file = f"{name}_{counter:05}.{file_format}"
-            with open(os.path.join(full_output_folder, file), "wb") as f:
-                f.write(encoded)
-
-            results.append({"filename": file, "subfolder": subfolder, "type": "output"})
-            counter += 1
-
-        return IO.NodeOutput(ui={"images": results})
-
-
 class ImagesExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -1254,7 +847,6 @@ class ImagesExtension(ComfyExtension):
             ImageAddNoise,
             SaveAnimatedWEBP,
             SaveAnimatedPNG,
-            SaveImageAdvanced,
             SaveSVGNode,
             ImageStitch,
             ResizeAndPadImage,

main.py

@@ -286,8 +286,8 @@ def prompt_worker(q, server_instance):
     cache_ram = 0
     cache_ram_inactive = 0
     if not args.cache_classic and not args.cache_none and args.cache_lru <= 0:
-        cache_ram = min(10.0, max(2.0, comfy.model_management.total_ram * 0.10 / 1024.0))
-        cache_ram_inactive = min(96.0, comfy.model_management.total_ram / 1024.0)
+        cache_ram = min(32.0, max(4.0, comfy.model_management.total_ram * 0.25 / 1024.0))
+        cache_ram_inactive = min(96.0, max(12.0, comfy.model_management.total_ram * 0.75 / 1024.0))
         if len(args.cache_ram) > 0:
             cache_ram = args.cache_ram[0]
         if len(args.cache_ram) > 1:
@@ -344,9 +344,9 @@ def prompt_worker(q, server_instance):
             # Log Time in a more readable way after 10 minutes
             if execution_time > 600:
                 execution_time = time.strftime("%H:%M:%S", time.gmtime(execution_time))
-                logging.info(f"Prompt executed in {execution_time}", extra={'color': 'green'})
+                logging.info(f"Prompt executed in {execution_time}")
             else:
-                logging.info("Prompt executed in {:.2f} seconds".format(execution_time), extra={'color': 'green'})
+                logging.info("Prompt executed in {:.2f} seconds".format(execution_time))
 
             if not asset_seeder.is_disabled():
                 paths = _collect_output_absolute_paths(e.history_result)

openapi.yaml

@@ -9585,9 +9585,16 @@ components:
           description: List of plan features
 
     BillingStatus:
-      type: string
+      type: object
       x-runtime: [cloud]
-      description: "[cloud-only] Overall billing/payment lifecycle status."
+      description: "[cloud-only] Overall billing and subscription status."
+      properties:
+        subscription:
+          $ref: "#/components/schemas/BillingSubscription"
+        balance:
+          $ref: "#/components/schemas/BillingBalance"
+        has_payment_method:
+          type: boolean
       enum:
         - awaiting_payment_method
         - pending_payment

requirements.txt

@@ -1,4 +1,4 @@
-comfyui-frontend-package==1.44.19
+comfyui-frontend-package==1.43.18
 comfyui-workflow-templates==0.9.82
 comfyui-embedded-docs==0.5.0
 torch
@@ -23,7 +23,7 @@ SQLAlchemy>=2.0.0
 filelock
 av>=14.2.0
 comfy-kitchen>=0.2.8
-comfy-aimdo==0.4.5
+comfy-aimdo==0.4.3
 requests
 simpleeval>=1.0.0
 blake3