Merge branch 'master' into ben/release-webhook-dispatch-desktop

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

comfy/k_diffusion/sampling.py

@@ -1,11 +1,12 @@
 import math
+import time
 from functools import partial
 
 from scipy import integrate
 import torch
 from torch import nn
 import torchsde
-from tqdm.auto import tqdm
+from tqdm.auto import trange as trange_, tqdm
 
 from . import utils
 from . import deis
@@ -14,7 +15,34 @@ import comfy.model_patcher
 import comfy.model_sampling
 
 import comfy.memory_management
-from comfy.utils import model_trange as trange
+
+
+def trange(*args, **kwargs):
+    if comfy.memory_management.aimdo_allocator is None:
+        return trange_(*args, **kwargs)
+
+    pbar = trange_(*args, **kwargs, smoothing=1.0)
+    pbar._i = 0
+    pbar.set_postfix_str("  Model Initializing ...  ")
+
+    _update = pbar.update
+
+    def warmup_update(n=1):
+        pbar._i += 1
+        if pbar._i == 1:
+            pbar.i1_time = time.time()
+            pbar.set_postfix_str(" Model Initialization complete!  ")
+        elif pbar._i == 2:
+            #bring forward the effective start time based the the diff between first and second iteration
+            #to attempt to remove load overhead from the final step rate estimate.
+            pbar.start_t = pbar.i1_time - (time.time() - pbar.i1_time)
+            pbar.set_postfix_str("")
+
+        _update(n)
+
+    pbar.update = warmup_update
+    return pbar
+
 
 def append_zero(x):
     return torch.cat([x, x.new_zeros([1])])

comfy/model_management.py

@@ -1213,12 +1213,8 @@ def cast_to(weight, dtype=None, device=None, non_blocking=False, copy=False, str
 
         signature = comfy_aimdo.model_vbar.vbar_fault(weight._v)
         if signature is not None:
-            if comfy_aimdo.model_vbar.vbar_signature_compare(signature, weight._v_signature):
-                v_tensor = weight._v_tensor
-            else:
-                raw_tensor = comfy_aimdo.torch.aimdo_to_tensor(weight._v, device)
-                v_tensor = comfy.memory_management.interpret_gathered_like(cast_geometry, raw_tensor)[0]
-                weight._v_tensor = v_tensor
+            v_tensor = comfy.memory_management.interpret_gathered_like(cast_geometry, weight._v_tensor)[0]
+            if not comfy_aimdo.model_vbar.vbar_signature_compare(signature, weight._v_signature):
                 weight._v_signature = signature
                 #Send it over
                 v_tensor.copy_(weight, non_blocking=non_blocking)

comfy/model_patcher.py

@@ -1525,7 +1525,7 @@ class ModelPatcherDynamic(ModelPatcher):
                     setattr(m, param_key + "_function", weight_function)
                     geometry = weight
                     if not isinstance(weight, QuantizedTensor):
-                        model_dtype = getattr(m, param_key + "_comfy_model_dtype", None) or weight.dtype
+                        model_dtype = getattr(m, param_key + "_comfy_model_dtype", weight.dtype)
                         weight._model_dtype = model_dtype
                         geometry = comfy.memory_management.TensorGeometry(shape=weight.shape, dtype=model_dtype)
                     return comfy.memory_management.vram_aligned_size(geometry)
@@ -1542,6 +1542,7 @@ class ModelPatcherDynamic(ModelPatcher):
 
                     if vbar is not None and not hasattr(m, "_v"):
                         m._v = vbar.alloc(v_weight_size)
+                        m._v_tensor = comfy_aimdo.torch.aimdo_to_tensor(m._v, device_to)
                     allocated_size += v_weight_size
 
                 else:
@@ -1551,11 +1552,12 @@ class ModelPatcherDynamic(ModelPatcher):
                         weight.seed_key = key
                         set_dirty(weight, dirty)
                         geometry = weight
-                        model_dtype = getattr(m, param + "_comfy_model_dtype", None) or weight.dtype
+                        model_dtype = getattr(m, param + "_comfy_model_dtype", weight.dtype)
                         geometry = comfy.memory_management.TensorGeometry(shape=weight.shape, dtype=model_dtype)
                         weight_size = geometry.numel() * geometry.element_size()
                         if vbar is not None and not hasattr(weight, "_v"):
                             weight._v = vbar.alloc(weight_size)
+                            weight._v_tensor = comfy_aimdo.torch.aimdo_to_tensor(weight._v, device_to)
                             weight._model_dtype = model_dtype
                         allocated_size += weight_size
                     vbar.set_watermark_limit(allocated_size)

comfy/ops.py

@@ -83,18 +83,14 @@ def cast_to_input(weight, input, non_blocking=False, copy=True):
 def cast_bias_weight_with_vbar(s, dtype, device, bias_dtype, non_blocking, compute_dtype):
     offload_stream = None
     xfer_dest = None
+    cast_geometry = comfy.memory_management.tensors_to_geometries([ s.weight, s.bias ])
 
     signature = comfy_aimdo.model_vbar.vbar_fault(s._v)
-    resident = comfy_aimdo.model_vbar.vbar_signature_compare(signature, s._v_signature)
     if signature is not None:
-        if resident:
-            weight = s._v_weight
-            bias = s._v_bias
-        else:
-            xfer_dest = comfy_aimdo.torch.aimdo_to_tensor(s._v, device)
+        xfer_dest = s._v_tensor
+    resident = comfy_aimdo.model_vbar.vbar_signature_compare(signature, s._v_signature)
 
     if not resident:
-        cast_geometry = comfy.memory_management.tensors_to_geometries([ s.weight, s.bias ])
         cast_dest = None
 
         xfer_source = [ s.weight, s.bias ]
@@ -144,13 +140,9 @@ def cast_bias_weight_with_vbar(s, dtype, device, bias_dtype, non_blocking, compu
                     post_cast.copy_(pre_cast)
             xfer_dest = cast_dest
 
-        params = comfy.memory_management.interpret_gathered_like(cast_geometry, xfer_dest)
-        weight = params[0]
-        bias = params[1]
-        if signature is not None:
-            s._v_weight = weight
-            s._v_bias = bias
-        s._v_signature=signature
+    params = comfy.memory_management.interpret_gathered_like(cast_geometry, xfer_dest)
+    weight = params[0]
+    bias = params[1]
 
     def post_cast(s, param_key, x, dtype, resident, update_weight):
         lowvram_fn = getattr(s, param_key + "_lowvram_function", None)
@@ -190,6 +182,7 @@ def cast_bias_weight_with_vbar(s, dtype, device, bias_dtype, non_blocking, compu
     weight = post_cast(s, "weight", weight, dtype, resident, update_weight)
     if s.bias is not None:
         bias = post_cast(s, "bias", bias, bias_dtype, resident, update_weight)
+    s._v_signature=signature
 
     #FIXME: weird offload return protocol
     return weight, bias, (offload_stream, device if signature is not None else None, None)

comfy/text_encoders/ace15.py

@@ -3,6 +3,7 @@ import comfy.text_encoders.llama
 from comfy import sd1_clip
 import torch
 import math
+from tqdm.auto import trange
 import yaml
 import comfy.utils
 
@@ -16,7 +17,6 @@ def sample_manual_loop_no_classes(
     temperature: float = 0.85,
     top_p: float = 0.9,
     top_k: int = None,
-    min_p: float = 0.000,
     seed: int = 1,
     min_tokens: int = 1,
     max_new_tokens: int = 2048,
@@ -52,7 +52,7 @@ def sample_manual_loop_no_classes(
 
     progress_bar = comfy.utils.ProgressBar(max_new_tokens)
 
-    for step in comfy.utils.model_trange(max_new_tokens, desc="LM sampling"):
+    for step in trange(max_new_tokens, desc="LM sampling"):
         outputs = model.transformer(None, attention_mask, embeds=embeds.to(execution_dtype), num_tokens=num_tokens, intermediate_output=None, dtype=execution_dtype, embeds_info=embeds_info, past_key_values=past_key_values)
         next_token_logits = model.transformer.logits(outputs[0])[:, -1]
         past_key_values = outputs[2]
@@ -81,12 +81,6 @@ def sample_manual_loop_no_classes(
             min_val = top_k_vals[..., -1, None]
             cfg_logits[cfg_logits < min_val] = remove_logit_value
 
-        if min_p is not None and min_p > 0:
-            probs = torch.softmax(cfg_logits, dim=-1)
-            p_max = probs.max(dim=-1, keepdim=True).values
-            indices_to_remove = probs < (min_p * p_max)
-            cfg_logits[indices_to_remove] = remove_logit_value
-
         if top_p is not None and top_p < 1.0:
             sorted_logits, sorted_indices = torch.sort(cfg_logits, descending=True)
             cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
@@ -117,7 +111,7 @@ def sample_manual_loop_no_classes(
     return output_audio_codes
 
 
-def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=1024, seed=0, cfg_scale=2.0, temperature=0.85, top_p=0.9, top_k=0, min_p=0.000):
+def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=1024, seed=0, cfg_scale=2.0, temperature=0.85, top_p=0.9, top_k=0):
     positive = [[token for token, _ in inner_list] for inner_list in positive]
     positive = positive[0]
 
@@ -141,7 +135,7 @@ def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=102
         paddings = []
         ids = [positive]
 
-    return sample_manual_loop_no_classes(model, ids, paddings, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k, min_p=min_p, seed=seed, min_tokens=min_tokens, max_new_tokens=max_tokens)
+    return sample_manual_loop_no_classes(model, ids, paddings, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k, seed=seed, min_tokens=min_tokens, max_new_tokens=max_tokens)
 
 
 class ACE15Tokenizer(sd1_clip.SD1Tokenizer):
@@ -199,7 +193,6 @@ class ACE15Tokenizer(sd1_clip.SD1Tokenizer):
         temperature = kwargs.get("temperature", 0.85)
         top_p = kwargs.get("top_p", 0.9)
         top_k = kwargs.get("top_k", 0.0)
-        min_p = kwargs.get("min_p", 0.000)
 
         duration = math.ceil(duration)
         kwargs["duration"] = duration
@@ -247,7 +240,6 @@ class ACE15Tokenizer(sd1_clip.SD1Tokenizer):
                               "temperature": temperature,
                               "top_p": top_p,
                               "top_k": top_k,
-                              "min_p": min_p,
                               }
         return out
 
@@ -308,7 +300,7 @@ class ACE15TEModel(torch.nn.Module):
 
         lm_metadata = token_weight_pairs["lm_metadata"]
         if lm_metadata["generate_audio_codes"]:
-            audio_codes = generate_audio_codes(getattr(self, self.lm_model, self.qwen3_06b), token_weight_pairs["lm_prompt"], token_weight_pairs["lm_prompt_negative"], min_tokens=lm_metadata["min_tokens"], max_tokens=lm_metadata["min_tokens"], seed=lm_metadata["seed"], cfg_scale=lm_metadata["cfg_scale"], temperature=lm_metadata["temperature"], top_p=lm_metadata["top_p"], top_k=lm_metadata["top_k"], min_p=lm_metadata["min_p"])
+            audio_codes = generate_audio_codes(getattr(self, self.lm_model, self.qwen3_06b), token_weight_pairs["lm_prompt"], token_weight_pairs["lm_prompt_negative"], min_tokens=lm_metadata["min_tokens"], max_tokens=lm_metadata["max_tokens"], seed=lm_metadata["seed"], cfg_scale=lm_metadata["cfg_scale"], temperature=lm_metadata["temperature"], top_p=lm_metadata["top_p"], top_k=lm_metadata["top_k"])
             out["audio_codes"] = [audio_codes]
 
         return base_out, None, out

comfy/utils.py

@@ -27,7 +27,6 @@ from PIL import Image
 import logging
 import itertools
 from torch.nn.functional import interpolate
-from tqdm.auto import trange
 from einops import rearrange
 from comfy.cli_args import args, enables_dynamic_vram
 import json
@@ -1156,32 +1155,6 @@ def tiled_scale_multidim(samples, function, tile=(64, 64), overlap=8, upscale_am
 def tiled_scale(samples, function, tile_x=64, tile_y=64, overlap = 8, upscale_amount = 4, out_channels = 3, output_device="cpu", pbar = None):
     return tiled_scale_multidim(samples, function, (tile_y, tile_x), overlap=overlap, upscale_amount=upscale_amount, out_channels=out_channels, output_device=output_device, pbar=pbar)
 
-def model_trange(*args, **kwargs):
-    if comfy.memory_management.aimdo_allocator is None:
-        return trange(*args, **kwargs)
-
-    pbar = trange(*args, **kwargs, smoothing=1.0)
-    pbar._i = 0
-    pbar.set_postfix_str("  Model Initializing ...  ")
-
-    _update = pbar.update
-
-    def warmup_update(n=1):
-        pbar._i += 1
-        if pbar._i == 1:
-            pbar.i1_time = time.time()
-            pbar.set_postfix_str(" Model Initialization complete!  ")
-        elif pbar._i == 2:
-            #bring forward the effective start time based the the diff between first and second iteration
-            #to attempt to remove load overhead from the final step rate estimate.
-            pbar.start_t = pbar.i1_time - (time.time() - pbar.i1_time)
-            pbar.set_postfix_str("")
-
-        _update(n)
-
-    pbar.update = warmup_update
-    return pbar
-
 PROGRESS_BAR_ENABLED = True
 def set_progress_bar_enabled(enabled):
     global PROGRESS_BAR_ENABLED

comfy_api/latest/_io.py

@@ -1203,89 +1203,6 @@ class Color(ComfyTypeIO):
       def as_dict(self):
           return super().as_dict()
 
-@comfytype(io_type="COLOR_CORRECT")
-class ColorCorrect(ComfyTypeIO):
-    Type = dict
-
-    class Input(WidgetInput):
-        def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                     socketless: bool=True, default: dict=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, None, default, socketless, None, None, None, None, advanced)
-            if default is None:
-                self.default = {
-                    "temperature": 0,
-                    "hue": 0,
-                    "brightness": 0,
-                    "contrast": 0,
-                    "saturation": 0,
-                    "gamma": 1.0
-                }
-
-        def as_dict(self):
-            return super().as_dict()
-
-@comfytype(io_type="COLOR_BALANCE")
-class ColorBalance(ComfyTypeIO):
-    Type = dict
-
-    class Input(WidgetInput):
-        def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                     socketless: bool=True, default: dict=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, None, default, socketless, None, None, None, None, advanced)
-            if default is None:
-                self.default = {
-                    "shadows_red": 0,
-                    "shadows_green": 0,
-                    "shadows_blue": 0,
-                    "midtones_red": 0,
-                    "midtones_green": 0,
-                    "midtones_blue": 0,
-                    "highlights_red": 0,
-                    "highlights_green": 0,
-                    "highlights_blue": 0
-                }
-
-        def as_dict(self):
-            return super().as_dict()
-
-@comfytype(io_type="COLOR_CURVES")
-class ColorCurves(ComfyTypeIO):
-    Type = dict
-
-    class Input(WidgetInput):
-        def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                     socketless: bool=True, default: dict=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, None, default, socketless, None, None, None, None, advanced)
-            if default is None:
-                self.default = {
-                    "rgb": [[0, 0], [1, 1]],
-                    "red": [[0, 0], [1, 1]],
-                    "green": [[0, 0], [1, 1]],
-                    "blue": [[0, 0], [1, 1]]
-                }
-
-        def as_dict(self):
-            return super().as_dict()
-
-@comfytype(io_type="BOUNDING_BOX")
-class BoundingBox(ComfyTypeIO):
-    Type = dict
-
-    class Input(WidgetInput):
-        def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                     socketless: bool=True, default: dict=None, component: str=None):
-            super().__init__(id, display_name, optional, tooltip, None, default, socketless)
-            self.component = component
-            if default is None:
-                self.default = {"x": 0, "y": 0, "width": 512, "height": 512}
-
-        def as_dict(self):
-            d = super().as_dict()
-            if self.component:
-                d["component"] = self.component
-            return d
-
-
 DYNAMIC_INPUT_LOOKUP: dict[str, Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]] = {}
 def register_dynamic_input_func(io_type: str, func: Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]):
     DYNAMIC_INPUT_LOOKUP[io_type] = func
@@ -2204,8 +2121,4 @@ __all__ = [
     "ImageCompare",
     "PriceBadgeDepends",
     "PriceBadge",
-    "BoundingBox",
-    "ColorCorrect",
-    "ColorBalance",
-    "ColorCurves"
 ]

comfy_api_nodes/nodes_magnific.py

@@ -30,30 +30,6 @@ from comfy_api_nodes.util import (
     validate_image_dimensions,
 )
 
-_EUR_TO_USD = 1.19
-
-
-def _tier_price_eur(megapixels: float) -> float:
-    """Price in EUR for a single Magnific upscaling step based on input megapixels."""
-    if megapixels <= 1.3:
-        return 0.143
-    if megapixels <= 3.0:
-        return 0.286
-    if megapixels <= 6.4:
-        return 0.429
-    return 1.716
-
-
-def _calculate_magnific_upscale_price_usd(width: int, height: int, scale: int) -> float:
-    """Calculate total Magnific upscale price in USD for given input dimensions and scale factor."""
-    num_steps = int(math.log2(scale))
-    total_eur = 0.0
-    pixels = width * height
-    for _ in range(num_steps):
-        total_eur += _tier_price_eur(pixels / 1_000_000)
-        pixels *= 4
-    return round(total_eur * _EUR_TO_USD, 2)
-
 
 class MagnificImageUpscalerCreativeNode(IO.ComfyNode):
     @classmethod
@@ -127,20 +103,11 @@ class MagnificImageUpscalerCreativeNode(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["scale_factor", "auto_downscale"]),
+                depends_on=IO.PriceBadgeDepends(widgets=["scale_factor"]),
                 expr="""
                 (
-                  $ad := widgets.auto_downscale;
-                  $mins := $ad
-                    ? {"2x": 0.172, "4x": 0.343, "8x": 0.515, "16x": 0.515}
-                    : {"2x": 0.172, "4x": 0.343, "8x": 0.515, "16x": 0.844};
-                  $maxs := {"2x": 0.515, "4x": 0.844, "8x": 1.015, "16x": 1.187};
-                  {
-                    "type": "range_usd",
-                    "min_usd": $lookup($mins, widgets.scale_factor),
-                    "max_usd": $lookup($maxs, widgets.scale_factor),
-                    "format": { "approximate": true }
-                  }
+                  $max := widgets.scale_factor = "2x" ? 1.326 : 1.657;
+                  {"type": "range_usd", "min_usd": 0.11, "max_usd": $max}
                 )
                 """,
             ),
@@ -201,10 +168,6 @@ class MagnificImageUpscalerCreativeNode(IO.ComfyNode):
                     f"Use a smaller input image or lower scale factor."
                 )
 
-        final_height, final_width = get_image_dimensions(image)
-        actual_scale = int(scale_factor.rstrip("x"))
-        price_usd = _calculate_magnific_upscale_price_usd(final_width, final_height, actual_scale)
-
         initial_res = await sync_op(
             cls,
             ApiEndpoint(path="/proxy/freepik/v1/ai/image-upscaler", method="POST"),
@@ -226,7 +189,6 @@ class MagnificImageUpscalerCreativeNode(IO.ComfyNode):
             ApiEndpoint(path=f"/proxy/freepik/v1/ai/image-upscaler/{initial_res.task_id}"),
             response_model=TaskResponse,
             status_extractor=lambda x: x.status,
-            price_extractor=lambda _: price_usd,
             poll_interval=10.0,
             max_poll_attempts=480,
         )
@@ -295,14 +257,8 @@ class MagnificImageUpscalerPreciseV2Node(IO.ComfyNode):
                 depends_on=IO.PriceBadgeDepends(widgets=["scale_factor"]),
                 expr="""
                 (
-                  $mins := {"2x": 0.172, "4x": 0.343, "8x": 0.515, "16x": 0.844};
-                  $maxs := {"2x": 2.045, "4x": 2.545, "8x": 2.889, "16x": 3.06};
-                  {
-                    "type": "range_usd",
-                    "min_usd": $lookup($mins, widgets.scale_factor),
-                    "max_usd": $lookup($maxs, widgets.scale_factor),
-                    "format": { "approximate": true }
-                  }
+                  $max := widgets.scale_factor = "2x" ? 1.326 : 1.657;
+                  {"type": "range_usd", "min_usd": 0.11, "max_usd": $max}
                 )
                 """,
             ),
@@ -365,9 +321,6 @@ class MagnificImageUpscalerPreciseV2Node(IO.ComfyNode):
                     f"Use a smaller input image or lower scale factor."
                 )
 
-        final_height, final_width = get_image_dimensions(image)
-        price_usd = _calculate_magnific_upscale_price_usd(final_width, final_height, requested_scale)
-
         initial_res = await sync_op(
             cls,
             ApiEndpoint(path="/proxy/freepik/v1/ai/image-upscaler-precision-v2", method="POST"),
@@ -386,7 +339,6 @@ class MagnificImageUpscalerPreciseV2Node(IO.ComfyNode):
             ApiEndpoint(path=f"/proxy/freepik/v1/ai/image-upscaler-precision-v2/{initial_res.task_id}"),
             response_model=TaskResponse,
             status_extractor=lambda x: x.status,
-            price_extractor=lambda _: price_usd,
             poll_interval=10.0,
             max_poll_attempts=480,
         )
@@ -925,8 +877,8 @@ class MagnificExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
         return [
-            MagnificImageUpscalerCreativeNode,
-            MagnificImageUpscalerPreciseV2Node,
+            # MagnificImageUpscalerCreativeNode,
+            # MagnificImageUpscalerPreciseV2Node,
             MagnificImageStyleTransferNode,
             MagnificImageRelightNode,
             MagnificImageSkinEnhancerNode,

comfy_api_nodes/util/client.py

@@ -57,7 +57,6 @@ class _RequestConfig:
     files: dict[str, Any] | list[tuple[str, Any]] | None
     multipart_parser: Callable | None
     max_retries: int
-    max_retries_on_rate_limit: int
     retry_delay: float
     retry_backoff: float
     wait_label: str = "Waiting"
@@ -66,7 +65,6 @@ class _RequestConfig:
     final_label_on_success: str | None = "Completed"
     progress_origin_ts: float | None = None
     price_extractor: Callable[[dict[str, Any]], float | None] | None = None
-    is_rate_limited: Callable[[int, Any], bool] | None = None
 
 
 @dataclass
@@ -80,7 +78,7 @@ class _PollUIState:
     active_since: float | None = None  # start time of current active interval (None if queued)
 
 
-_RETRY_STATUS = {408, 500, 502, 503, 504}  # status 429 is handled separately
+_RETRY_STATUS = {408, 429, 500, 502, 503, 504}
 COMPLETED_STATUSES = ["succeeded", "succeed", "success", "completed", "finished", "done", "complete"]
 FAILED_STATUSES = ["cancelled", "canceled", "canceling", "fail", "failed", "error"]
 QUEUED_STATUSES = ["created", "queued", "queueing", "submitted", "initializing"]
@@ -105,8 +103,6 @@ async def sync_op(
     final_label_on_success: str | None = "Completed",
     progress_origin_ts: float | None = None,
     monitor_progress: bool = True,
-    max_retries_on_rate_limit: int = 16,
-    is_rate_limited: Callable[[int, Any], bool] | None = None,
 ) -> M:
     raw = await sync_op_raw(
         cls,
@@ -126,8 +122,6 @@ async def sync_op(
         final_label_on_success=final_label_on_success,
         progress_origin_ts=progress_origin_ts,
         monitor_progress=monitor_progress,
-        max_retries_on_rate_limit=max_retries_on_rate_limit,
-        is_rate_limited=is_rate_limited,
     )
     if not isinstance(raw, dict):
         raise Exception("Expected JSON response to validate into a Pydantic model, got non-JSON (binary or text).")
@@ -200,8 +194,6 @@ async def sync_op_raw(
     final_label_on_success: str | None = "Completed",
     progress_origin_ts: float | None = None,
     monitor_progress: bool = True,
-    max_retries_on_rate_limit: int = 16,
-    is_rate_limited: Callable[[int, Any], bool] | None = None,
 ) -> dict[str, Any] | bytes:
     """
     Make a single network request.
@@ -230,8 +222,6 @@ async def sync_op_raw(
         final_label_on_success=final_label_on_success,
         progress_origin_ts=progress_origin_ts,
         price_extractor=price_extractor,
-        max_retries_on_rate_limit=max_retries_on_rate_limit,
-        is_rate_limited=is_rate_limited,
     )
     return await _request_base(cfg, expect_binary=as_binary)
 
@@ -516,7 +506,7 @@ def _friendly_http_message(status: int, body: Any) -> str:
     if status == 409:
         return "There is a problem with your account. Please contact support@comfy.org."
     if status == 429:
-        return "Rate Limit Exceeded: The server returned 429 after all retry attempts. Please wait and try again."
+        return "Rate Limit Exceeded: Please try again later."
     try:
         if isinstance(body, dict):
             err = body.get("error")
@@ -596,8 +586,6 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
     start_time = cfg.progress_origin_ts if cfg.progress_origin_ts is not None else time.monotonic()
     attempt = 0
     delay = cfg.retry_delay
-    rate_limit_attempts = 0
-    rate_limit_delay = cfg.retry_delay
     operation_succeeded: bool = False
     final_elapsed_seconds: int | None = None
     extracted_price: float | None = None
@@ -665,14 +653,17 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                 payload_headers["Content-Type"] = "application/json"
                 payload_kw["json"] = cfg.data or {}
 
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method,
-                request_url=url,
-                request_headers=dict(payload_headers) if payload_headers else None,
-                request_params=dict(params) if params else None,
-                request_data=request_body_log,
-            )
+            try:
+                request_logger.log_request_response(
+                    operation_id=operation_id,
+                    request_method=method,
+                    request_url=url,
+                    request_headers=dict(payload_headers) if payload_headers else None,
+                    request_params=dict(params) if params else None,
+                    request_data=request_body_log,
+                )
+            except Exception as _log_e:
+                logging.debug("[DEBUG] request logging failed: %s", _log_e)
 
             req_coro = sess.request(method, url, params=params, **payload_kw)
             req_task = asyncio.create_task(req_coro)
@@ -697,33 +688,41 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                         body = await resp.json()
                     except (ContentTypeError, json.JSONDecodeError):
                         body = await resp.text()
-                    should_retry = False
-                    wait_time = 0.0
-                    retry_label = ""
-                    is_rl = resp.status == 429 or (
-                        cfg.is_rate_limited is not None and cfg.is_rate_limited(resp.status, body)
-                    )
-                    if is_rl and rate_limit_attempts < cfg.max_retries_on_rate_limit:
-                        rate_limit_attempts += 1
-                        wait_time = min(rate_limit_delay, 30.0)
-                        rate_limit_delay *= cfg.retry_backoff
-                        retry_label = f"rate-limit retry {rate_limit_attempts} of {cfg.max_retries_on_rate_limit}"
-                        should_retry = True
-                    elif resp.status in _RETRY_STATUS and (attempt - rate_limit_attempts) <= cfg.max_retries:
-                        wait_time = delay
-                        delay *= cfg.retry_backoff
-                        retry_label = f"retry {attempt - rate_limit_attempts} of {cfg.max_retries}"
-                        should_retry = True
-
-                    if should_retry:
+                    if resp.status in _RETRY_STATUS and attempt <= cfg.max_retries:
                         logging.warning(
-                            "HTTP %s %s -> %s. Waiting %.2fs (%s).",
+                            "HTTP %s %s -> %s. Retrying in %.2fs (retry %d of %d).",
                             method,
                             url,
                             resp.status,
-                            wait_time,
-                            retry_label,
+                            delay,
+                            attempt,
+                            cfg.max_retries,
                         )
+                        try:
+                            request_logger.log_request_response(
+                                operation_id=operation_id,
+                                request_method=method,
+                                request_url=url,
+                                response_status_code=resp.status,
+                                response_headers=dict(resp.headers),
+                                response_content=body,
+                                error_message=_friendly_http_message(resp.status, body),
+                            )
+                        except Exception as _log_e:
+                            logging.debug("[DEBUG] response logging failed: %s", _log_e)
+
+                        await sleep_with_interrupt(
+                            delay,
+                            cfg.node_cls,
+                            cfg.wait_label if cfg.monitor_progress else None,
+                            start_time if cfg.monitor_progress else None,
+                            cfg.estimated_total,
+                            display_callback=_display_time_progress if cfg.monitor_progress else None,
+                        )
+                        delay *= cfg.retry_backoff
+                        continue
+                    msg = _friendly_http_message(resp.status, body)
+                    try:
                         request_logger.log_request_response(
                             operation_id=operation_id,
                             request_method=method,
@@ -731,27 +730,10 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                             response_status_code=resp.status,
                             response_headers=dict(resp.headers),
                             response_content=body,
-                            error_message=f"HTTP {resp.status} ({retry_label}, will retry in {wait_time:.1f}s)",
+                            error_message=msg,
                         )
-                        await sleep_with_interrupt(
-                            wait_time,
-                            cfg.node_cls,
-                            cfg.wait_label if cfg.monitor_progress else None,
-                            start_time if cfg.monitor_progress else None,
-                            cfg.estimated_total,
-                            display_callback=_display_time_progress if cfg.monitor_progress else None,
-                        )
-                        continue
-                    msg = _friendly_http_message(resp.status, body)
-                    request_logger.log_request_response(
-                        operation_id=operation_id,
-                        request_method=method,
-                        request_url=url,
-                        response_status_code=resp.status,
-                        response_headers=dict(resp.headers),
-                        response_content=body,
-                        error_message=msg,
-                    )
+                    except Exception as _log_e:
+                        logging.debug("[DEBUG] response logging failed: %s", _log_e)
                     raise Exception(msg)
 
                 if expect_binary:
@@ -771,14 +753,17 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                     bytes_payload = bytes(buff)
                     operation_succeeded = True
                     final_elapsed_seconds = int(time.monotonic() - start_time)
-                    request_logger.log_request_response(
-                        operation_id=operation_id,
-                        request_method=method,
-                        request_url=url,
-                        response_status_code=resp.status,
-                        response_headers=dict(resp.headers),
-                        response_content=bytes_payload,
-                    )
+                    try:
+                        request_logger.log_request_response(
+                            operation_id=operation_id,
+                            request_method=method,
+                            request_url=url,
+                            response_status_code=resp.status,
+                            response_headers=dict(resp.headers),
+                            response_content=bytes_payload,
+                        )
+                    except Exception as _log_e:
+                        logging.debug("[DEBUG] response logging failed: %s", _log_e)
                     return bytes_payload
                 else:
                     try:
@@ -795,39 +780,45 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                         extracted_price = cfg.price_extractor(payload) if cfg.price_extractor else None
                     operation_succeeded = True
                     final_elapsed_seconds = int(time.monotonic() - start_time)
-                    request_logger.log_request_response(
-                        operation_id=operation_id,
-                        request_method=method,
-                        request_url=url,
-                        response_status_code=resp.status,
-                        response_headers=dict(resp.headers),
-                        response_content=response_content_to_log,
-                    )
+                    try:
+                        request_logger.log_request_response(
+                            operation_id=operation_id,
+                            request_method=method,
+                            request_url=url,
+                            response_status_code=resp.status,
+                            response_headers=dict(resp.headers),
+                            response_content=response_content_to_log,
+                        )
+                    except Exception as _log_e:
+                        logging.debug("[DEBUG] response logging failed: %s", _log_e)
                     return payload
 
         except ProcessingInterrupted:
             logging.debug("Polling was interrupted by user")
             raise
         except (ClientError, OSError) as e:
-            if (attempt - rate_limit_attempts) <= cfg.max_retries:
+            if attempt <= cfg.max_retries:
                 logging.warning(
                     "Connection error calling %s %s. Retrying in %.2fs (%d/%d): %s",
                     method,
                     url,
                     delay,
-                    attempt - rate_limit_attempts,
+                    attempt,
                     cfg.max_retries,
                     str(e),
                 )
-                request_logger.log_request_response(
-                    operation_id=operation_id,
-                    request_method=method,
-                    request_url=url,
-                    request_headers=dict(payload_headers) if payload_headers else None,
-                    request_params=dict(params) if params else None,
-                    request_data=request_body_log,
-                    error_message=f"{type(e).__name__}: {str(e)} (will retry)",
-                )
+                try:
+                    request_logger.log_request_response(
+                        operation_id=operation_id,
+                        request_method=method,
+                        request_url=url,
+                        request_headers=dict(payload_headers) if payload_headers else None,
+                        request_params=dict(params) if params else None,
+                        request_data=request_body_log,
+                        error_message=f"{type(e).__name__}: {str(e)} (will retry)",
+                    )
+                except Exception as _log_e:
+                    logging.debug("[DEBUG] request error logging failed: %s", _log_e)
                 await sleep_with_interrupt(
                     delay,
                     cfg.node_cls,
@@ -840,6 +831,23 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                 continue
             diag = await _diagnose_connectivity()
             if not diag["internet_accessible"]:
+                try:
+                    request_logger.log_request_response(
+                        operation_id=operation_id,
+                        request_method=method,
+                        request_url=url,
+                        request_headers=dict(payload_headers) if payload_headers else None,
+                        request_params=dict(params) if params else None,
+                        request_data=request_body_log,
+                        error_message=f"LocalNetworkError: {str(e)}",
+                    )
+                except Exception as _log_e:
+                    logging.debug("[DEBUG] final error logging failed: %s", _log_e)
+                raise LocalNetworkError(
+                    "Unable to connect to the API server due to local network issues. "
+                    "Please check your internet connection and try again."
+                ) from e
+            try:
                 request_logger.log_request_response(
                     operation_id=operation_id,
                     request_method=method,
@@ -847,21 +855,10 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
                     request_headers=dict(payload_headers) if payload_headers else None,
                     request_params=dict(params) if params else None,
                     request_data=request_body_log,
-                    error_message=f"LocalNetworkError: {str(e)}",
+                    error_message=f"ApiServerError: {str(e)}",
                 )
-                raise LocalNetworkError(
-                    "Unable to connect to the API server due to local network issues. "
-                    "Please check your internet connection and try again."
-                ) from e
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method=method,
-                request_url=url,
-                request_headers=dict(payload_headers) if payload_headers else None,
-                request_params=dict(params) if params else None,
-                request_data=request_body_log,
-                error_message=f"ApiServerError: {str(e)}",
-            )
+            except Exception as _log_e:
+                logging.debug("[DEBUG] final error logging failed: %s", _log_e)
             raise ApiServerError(
                 f"The API server at {default_base_url()} is currently unreachable. "
                 f"The service may be experiencing issues."

comfy_api_nodes/util/download_helpers.py

@@ -167,25 +167,27 @@ async def download_url_to_bytesio(
                     with contextlib.suppress(Exception):
                         dest.seek(0)
 
-                request_logger.log_request_response(
-                    operation_id=op_id,
-                    request_method="GET",
-                    request_url=url,
-                    response_status_code=resp.status,
-                    response_headers=dict(resp.headers),
-                    response_content=f"[streamed {written} bytes to dest]",
-                )
+                with contextlib.suppress(Exception):
+                    request_logger.log_request_response(
+                        operation_id=op_id,
+                        request_method="GET",
+                        request_url=url,
+                        response_status_code=resp.status,
+                        response_headers=dict(resp.headers),
+                        response_content=f"[streamed {written} bytes to dest]",
+                    )
                 return
         except asyncio.CancelledError:
             raise ProcessingInterrupted("Task cancelled") from None
         except (ClientError, OSError) as e:
             if attempt <= max_retries:
-                request_logger.log_request_response(
-                    operation_id=op_id,
-                    request_method="GET",
-                    request_url=url,
-                    error_message=f"{type(e).__name__}: {str(e)} (will retry)",
-                )
+                with contextlib.suppress(Exception):
+                    request_logger.log_request_response(
+                        operation_id=op_id,
+                        request_method="GET",
+                        request_url=url,
+                        error_message=f"{type(e).__name__}: {str(e)} (will retry)",
+                    )
                 await sleep_with_interrupt(delay, cls, None, None, None)
                 delay *= retry_backoff
                 continue

comfy_api_nodes/util/request_logger.py

@@ -8,6 +8,7 @@ from typing import Any
 
 import folder_paths
 
+# Get the logger instance
 logger = logging.getLogger(__name__)
 
 
@@ -90,41 +91,38 @@ def log_request_response(
     Filenames are sanitized and length-limited for cross-platform safety.
     If we still fail to write, we fall back to appending into api.log.
     """
+    log_dir = get_log_directory()
+    filepath = _build_log_filepath(log_dir, operation_id, request_url)
+
+    log_content: list[str] = []
+    log_content.append(f"Timestamp: {datetime.datetime.now().isoformat()}")
+    log_content.append(f"Operation ID: {operation_id}")
+    log_content.append("-" * 30 + " REQUEST " + "-" * 30)
+    log_content.append(f"Method: {request_method}")
+    log_content.append(f"URL: {request_url}")
+    if request_headers:
+        log_content.append(f"Headers:\n{_format_data_for_logging(request_headers)}")
+    if request_params:
+        log_content.append(f"Params:\n{_format_data_for_logging(request_params)}")
+    if request_data is not None:
+        log_content.append(f"Data/Body:\n{_format_data_for_logging(request_data)}")
+
+    log_content.append("\n" + "-" * 30 + " RESPONSE " + "-" * 30)
+    if response_status_code is not None:
+        log_content.append(f"Status Code: {response_status_code}")
+    if response_headers:
+        log_content.append(f"Headers:\n{_format_data_for_logging(response_headers)}")
+    if response_content is not None:
+        log_content.append(f"Content:\n{_format_data_for_logging(response_content)}")
+    if error_message:
+        log_content.append(f"Error:\n{error_message}")
+
     try:
-        log_dir = get_log_directory()
-        filepath = _build_log_filepath(log_dir, operation_id, request_url)
-
-        log_content: list[str] = []
-        log_content.append(f"Timestamp: {datetime.datetime.now().isoformat()}")
-        log_content.append(f"Operation ID: {operation_id}")
-        log_content.append("-" * 30 + " REQUEST " + "-" * 30)
-        log_content.append(f"Method: {request_method}")
-        log_content.append(f"URL: {request_url}")
-        if request_headers:
-            log_content.append(f"Headers:\n{_format_data_for_logging(request_headers)}")
-        if request_params:
-            log_content.append(f"Params:\n{_format_data_for_logging(request_params)}")
-        if request_data is not None:
-            log_content.append(f"Data/Body:\n{_format_data_for_logging(request_data)}")
-
-        log_content.append("\n" + "-" * 30 + " RESPONSE " + "-" * 30)
-        if response_status_code is not None:
-            log_content.append(f"Status Code: {response_status_code}")
-        if response_headers:
-            log_content.append(f"Headers:\n{_format_data_for_logging(response_headers)}")
-        if response_content is not None:
-            log_content.append(f"Content:\n{_format_data_for_logging(response_content)}")
-        if error_message:
-            log_content.append(f"Error:\n{error_message}")
-
-        try:
-            with open(filepath, "w", encoding="utf-8") as f:
-                f.write("\n".join(log_content))
-            logger.debug("API log saved to: %s", filepath)
-        except Exception as e:
-            logger.error("Error writing API log to %s: %s", filepath, str(e))
-    except Exception as _log_e:
-        logging.debug("[DEBUG] log_request_response failed: %s", _log_e)
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write("\n".join(log_content))
+        logger.debug("API log saved to: %s", filepath)
+    except Exception as e:
+        logger.error("Error writing API log to %s: %s", filepath, str(e))
 
 
 if __name__ == '__main__':

comfy_api_nodes/util/upload_helpers.py

@@ -255,14 +255,17 @@ async def upload_file(
         monitor_task = asyncio.create_task(_monitor())
         sess: aiohttp.ClientSession | None = None
         try:
-            request_logger.log_request_response(
-                operation_id=operation_id,
-                request_method="PUT",
-                request_url=upload_url,
-                request_headers=headers or None,
-                request_params=None,
-                request_data=f"[File data {len(data)} bytes]",
-            )
+            try:
+                request_logger.log_request_response(
+                    operation_id=operation_id,
+                    request_method="PUT",
+                    request_url=upload_url,
+                    request_headers=headers or None,
+                    request_params=None,
+                    request_data=f"[File data {len(data)} bytes]",
+                )
+            except Exception as e:
+                logging.debug("[DEBUG] upload request logging failed: %s", e)
 
             sess = aiohttp.ClientSession(timeout=timeout)
             req = sess.put(upload_url, data=data, headers=headers, skip_auto_headers=skip_auto_headers)
@@ -308,27 +311,31 @@ async def upload_file(
                         delay *= retry_backoff
                         continue
                     raise Exception(f"Failed to upload (HTTP {resp.status}).")
-                request_logger.log_request_response(
-                    operation_id=operation_id,
-                    request_method="PUT",
-                    request_url=upload_url,
-                    response_status_code=resp.status,
-                    response_headers=dict(resp.headers),
-                    response_content="File uploaded successfully.",
-                )
+                try:
+                    request_logger.log_request_response(
+                        operation_id=operation_id,
+                        request_method="PUT",
+                        request_url=upload_url,
+                        response_status_code=resp.status,
+                        response_headers=dict(resp.headers),
+                        response_content="File uploaded successfully.",
+                    )
+                except Exception as e:
+                    logging.debug("[DEBUG] upload response logging failed: %s", e)
                 return
         except asyncio.CancelledError:
             raise ProcessingInterrupted("Task cancelled") from None
         except (aiohttp.ClientError, OSError) as e:
             if attempt <= max_retries:
-                request_logger.log_request_response(
-                    operation_id=operation_id,
-                    request_method="PUT",
-                    request_url=upload_url,
-                    request_headers=headers or None,
-                    request_data=f"[File data {len(data)} bytes]",
-                    error_message=f"{type(e).__name__}: {str(e)} (will retry)",
-                )
+                with contextlib.suppress(Exception):
+                    request_logger.log_request_response(
+                        operation_id=operation_id,
+                        request_method="PUT",
+                        request_url=upload_url,
+                        request_headers=headers or None,
+                        request_data=f"[File data {len(data)} bytes]",
+                        error_message=f"{type(e).__name__}: {str(e)} (will retry)",
+                    )
                 await sleep_with_interrupt(
                     delay,
                     cls,

comfy_extras/nodes_ace.py

@@ -49,14 +49,13 @@ class TextEncodeAceStepAudio15(io.ComfyNode):
                 io.Float.Input("temperature", default=0.85, min=0.0, max=2.0, step=0.01, advanced=True),
                 io.Float.Input("top_p", default=0.9, min=0.0, max=2000.0, step=0.01, advanced=True),
                 io.Int.Input("top_k", default=0, min=0, max=100, advanced=True),
-                io.Float.Input("min_p", default=0.000, min=0.0, max=1.0, step=0.001, advanced=True),
             ],
             outputs=[io.Conditioning.Output()],
         )
 
     @classmethod
-    def execute(cls, clip, tags, lyrics, seed, bpm, duration, timesignature, language, keyscale, generate_audio_codes, cfg_scale, temperature, top_p, top_k, min_p) -> io.NodeOutput:
-        tokens = clip.tokenize(tags, lyrics=lyrics, bpm=bpm, duration=duration, timesignature=int(timesignature), language=language, keyscale=keyscale, seed=seed, generate_audio_codes=generate_audio_codes, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k, min_p=min_p)
+    def execute(cls, clip, tags, lyrics, seed, bpm, duration, timesignature, language, keyscale, generate_audio_codes, cfg_scale, temperature, top_p, top_k) -> io.NodeOutput:
+        tokens = clip.tokenize(tags, lyrics=lyrics, bpm=bpm, duration=duration, timesignature=int(timesignature), language=language, keyscale=keyscale, seed=seed, generate_audio_codes=generate_audio_codes, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k)
         conditioning = clip.encode_from_tokens_scheduled(tokens)
         return io.NodeOutput(conditioning)
 

comfy_extras/nodes_color_balance.py

@@ -1,78 +0,0 @@
-from typing_extensions import override
-import torch
-
-from comfy_api.latest import ComfyExtension, io, ui
-
-
-def _smoothstep(edge0: float, edge1: float, x: torch.Tensor) -> torch.Tensor:
-    t = torch.clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0)
-    return t * t * (3.0 - 2.0 * t)
-
-
-class ColorBalanceNode(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="ColorBalance",
-            display_name="Color Balance",
-            category="image/adjustment",
-            inputs=[
-                io.Image.Input("image"),
-                io.ColorBalance.Input("settings"),
-            ],
-            outputs=[
-                io.Image.Output(),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, image: torch.Tensor, settings: dict) -> io.NodeOutput:
-        shadows_red = settings.get("shadows_red", 0)
-        shadows_green = settings.get("shadows_green", 0)
-        shadows_blue = settings.get("shadows_blue", 0)
-        midtones_red = settings.get("midtones_red", 0)
-        midtones_green = settings.get("midtones_green", 0)
-        midtones_blue = settings.get("midtones_blue", 0)
-        highlights_red = settings.get("highlights_red", 0)
-        highlights_green = settings.get("highlights_green", 0)
-        highlights_blue = settings.get("highlights_blue", 0)
-
-        result = image.clone().float()
-
-        # Compute per-pixel luminance
-        luminance = (
-            0.2126 * result[..., 0]
-            + 0.7152 * result[..., 1]
-            + 0.0722 * result[..., 2]
-        )
-
-        # Compute tonal range weights
-        shadow_weight = 1.0 - _smoothstep(0.0, 0.5, luminance)
-        highlight_weight = _smoothstep(0.5, 1.0, luminance)
-        midtone_weight = 1.0 - shadow_weight - highlight_weight
-
-        # Apply offsets per channel
-        for ch, (s, m, h) in enumerate([
-            (shadows_red, midtones_red, highlights_red),
-            (shadows_green, midtones_green, highlights_green),
-            (shadows_blue, midtones_blue, highlights_blue),
-        ]):
-            offset = (
-                shadow_weight * (s / 100.0)
-                + midtone_weight * (m / 100.0)
-                + highlight_weight * (h / 100.0)
-            )
-            result[..., ch] = result[..., ch] + offset
-
-        result = torch.clamp(result, 0, 1)
-        return io.NodeOutput(result, ui=ui.PreviewImage(result))
-
-
-class ColorBalanceExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[io.ComfyNode]]:
-        return [ColorBalanceNode]
-
-
-async def comfy_entrypoint() -> ColorBalanceExtension:
-    return ColorBalanceExtension()

comfy_extras/nodes_color_correct.py

@@ -1,88 +0,0 @@
-from typing_extensions import override
-import torch
-import numpy as np
-
-from comfy_api.latest import ComfyExtension, io, ui
-
-
-class ColorCorrectNode(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="ColorCorrect",
-            display_name="Color Correct",
-            category="image/adjustment",
-            inputs=[
-                io.Image.Input("image"),
-                io.ColorCorrect.Input("settings"),
-            ],
-            outputs=[
-                io.Image.Output(),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, image: torch.Tensor, settings: dict) -> io.NodeOutput:
-        temperature = settings.get("temperature", 0)
-        hue = settings.get("hue", 0)
-        brightness = settings.get("brightness", 0)
-        contrast = settings.get("contrast", 0)
-        saturation = settings.get("saturation", 0)
-        gamma = settings.get("gamma", 1.0)
-
-        result = image.clone()
-
-        # Brightness: scale RGB values
-        if brightness != 0:
-            factor = 1.0 + brightness / 100.0
-            result = result * factor
-
-        # Contrast: adjust around midpoint
-        if contrast != 0:
-            factor = 1.0 + contrast / 100.0
-            mean = result[..., :3].mean()
-            result[..., :3] = (result[..., :3] - mean) * factor + mean
-
-        # Temperature: shift warm (red+) / cool (blue+)
-        if temperature != 0:
-            temp_factor = temperature / 100.0
-            result[..., 0] = result[..., 0] + temp_factor * 0.1  # Red
-            result[..., 2] = result[..., 2] - temp_factor * 0.1  # Blue
-
-        # Gamma correction
-        if gamma != 1.0:
-            result[..., :3] = torch.pow(torch.clamp(result[..., :3], 0, 1), 1.0 / gamma)
-
-        # Saturation: convert to HSV-like space
-        if saturation != 0:
-            factor = 1.0 + saturation / 100.0
-            gray = result[..., :3].mean(dim=-1, keepdim=True)
-            result[..., :3] = gray + (result[..., :3] - gray) * factor
-
-        # Hue rotation: rotate in RGB space using rotation matrix
-        if hue != 0:
-            angle = np.radians(hue)
-            cos_a = np.cos(angle)
-            sin_a = np.sin(angle)
-            # Rodrigues' rotation formula around (1,1,1)/sqrt(3) axis
-            k = 1.0 / 3.0
-            rotation = torch.tensor([
-                [cos_a + k * (1 - cos_a), k * (1 - cos_a) - sin_a / np.sqrt(3), k * (1 - cos_a) + sin_a / np.sqrt(3)],
-                [k * (1 - cos_a) + sin_a / np.sqrt(3), cos_a + k * (1 - cos_a), k * (1 - cos_a) - sin_a / np.sqrt(3)],
-                [k * (1 - cos_a) - sin_a / np.sqrt(3), k * (1 - cos_a) + sin_a / np.sqrt(3), cos_a + k * (1 - cos_a)]
-            ], dtype=result.dtype, device=result.device)
-            rgb = result[..., :3]
-            result[..., :3] = torch.matmul(rgb, rotation.T)
-
-        result = torch.clamp(result, 0, 1)
-        return io.NodeOutput(result, ui=ui.PreviewImage(result))
-
-
-class ColorCorrectExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[io.ComfyNode]]:
-        return [ColorCorrectNode]
-
-
-async def comfy_entrypoint() -> ColorCorrectExtension:
-    return ColorCorrectExtension()

comfy_extras/nodes_color_curves.py

@@ -1,137 +0,0 @@
-from typing_extensions import override
-import torch
-import numpy as np
-
-from comfy_api.latest import ComfyExtension, io, ui
-
-
-def _monotone_cubic_hermite(xs, ys, x_query):
-    """Evaluate monotone cubic Hermite interpolation at x_query points."""
-    n = len(xs)
-    if n == 0:
-        return np.zeros_like(x_query)
-    if n == 1:
-        return np.full_like(x_query, ys[0])
-
-    # Compute slopes
-    deltas = np.diff(ys) / np.maximum(np.diff(xs), 1e-10)
-
-    # Compute tangents (Fritsch-Carlson)
-    slopes = np.zeros(n)
-    slopes[0] = deltas[0]
-    slopes[-1] = deltas[-1]
-    for i in range(1, n - 1):
-        if deltas[i - 1] * deltas[i] <= 0:
-            slopes[i] = 0
-        else:
-            slopes[i] = (deltas[i - 1] + deltas[i]) / 2
-
-    # Enforce monotonicity
-    for i in range(n - 1):
-        if deltas[i] == 0:
-            slopes[i] = 0
-            slopes[i + 1] = 0
-        else:
-            alpha = slopes[i] / deltas[i]
-            beta = slopes[i + 1] / deltas[i]
-            s = alpha ** 2 + beta ** 2
-            if s > 9:
-                t = 3 / np.sqrt(s)
-                slopes[i] = t * alpha * deltas[i]
-                slopes[i + 1] = t * beta * deltas[i]
-
-    # Evaluate
-    result = np.zeros_like(x_query, dtype=np.float64)
-    indices = np.searchsorted(xs, x_query, side='right') - 1
-    indices = np.clip(indices, 0, n - 2)
-
-    for i in range(n - 1):
-        mask = indices == i
-        if not np.any(mask):
-            continue
-        dx = xs[i + 1] - xs[i]
-        if dx == 0:
-            result[mask] = ys[i]
-            continue
-        t = (x_query[mask] - xs[i]) / dx
-        t2 = t * t
-        t3 = t2 * t
-        h00 = 2 * t3 - 3 * t2 + 1
-        h10 = t3 - 2 * t2 + t
-        h01 = -2 * t3 + 3 * t2
-        h11 = t3 - t2
-        result[mask] = h00 * ys[i] + h10 * dx * slopes[i] + h01 * ys[i + 1] + h11 * dx * slopes[i + 1]
-
-    # Clamp edges
-    result[x_query <= xs[0]] = ys[0]
-    result[x_query >= xs[-1]] = ys[-1]
-
-    return result
-
-
-def _build_lut(points):
-    """Build a 256-entry LUT from curve control points in [0,1] space."""
-    if not points or len(points) < 2:
-        return np.arange(256, dtype=np.float64) / 255.0
-
-    pts = sorted(points, key=lambda p: p[0])
-    xs = np.array([p[0] for p in pts], dtype=np.float64)
-    ys = np.array([p[1] for p in pts], dtype=np.float64)
-
-    x_query = np.linspace(0, 1, 256)
-    lut = _monotone_cubic_hermite(xs, ys, x_query)
-    return np.clip(lut, 0, 1)
-
-
-class ColorCurvesNode(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="ColorCurves",
-            display_name="Color Curves",
-            category="image/adjustment",
-            inputs=[
-                io.Image.Input("image"),
-                io.ColorCurves.Input("settings"),
-            ],
-            outputs=[
-                io.Image.Output(),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, image: torch.Tensor, settings: dict) -> io.NodeOutput:
-        rgb_pts = settings.get("rgb", [[0, 0], [1, 1]])
-        red_pts = settings.get("red", [[0, 0], [1, 1]])
-        green_pts = settings.get("green", [[0, 0], [1, 1]])
-        blue_pts = settings.get("blue", [[0, 0], [1, 1]])
-
-        rgb_lut = _build_lut(rgb_pts)
-        red_lut = _build_lut(red_pts)
-        green_lut = _build_lut(green_pts)
-        blue_lut = _build_lut(blue_pts)
-
-        # Convert to numpy for LUT application
-        img_np = image.cpu().numpy().copy()
-
-        # Apply per-channel curves then RGB master curve
-        for ch, ch_lut in enumerate([red_lut, green_lut, blue_lut]):
-            # Per-channel curve
-            indices = np.clip(img_np[..., ch] * 255, 0, 255).astype(np.int32)
-            img_np[..., ch] = ch_lut[indices]
-            # RGB master curve
-            indices = np.clip(img_np[..., ch] * 255, 0, 255).astype(np.int32)
-            img_np[..., ch] = rgb_lut[indices]
-
-        result = torch.from_numpy(np.clip(img_np, 0, 1)).to(image.device, dtype=image.dtype)
-        return io.NodeOutput(result, ui=ui.PreviewImage(result))
-
-
-class ColorCurvesExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[io.ComfyNode]]:
-        return [ColorCurvesNode]
-
-
-async def comfy_entrypoint() -> ColorCurvesExtension:
-    return ColorCurvesExtension()

comfy_extras/nodes_images.py

@@ -23,9 +23,8 @@ class ImageCrop(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageCrop",
             search_aliases=["trim"],
-            display_name="Image Crop (Deprecated)",
+            display_name="Image Crop",
             category="image/transform",
-            is_deprecated=True,
             inputs=[
                 IO.Image.Input("image"),
                 IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),
@@ -48,57 +47,6 @@ class ImageCrop(IO.ComfyNode):
     crop = execute  # TODO: remove
 
 
-class ImageCropV2(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="ImageCropV2",
-            search_aliases=["trim"],
-            display_name="Image Crop",
-            category="image/transform",
-            inputs=[
-                IO.Image.Input("image"),
-                IO.BoundingBox.Input("crop_region", component="ImageCrop"),
-            ],
-            outputs=[IO.Image.Output()],
-        )
-
-    @classmethod
-    def execute(cls, image, crop_region) -> IO.NodeOutput:
-        x = crop_region.get("x", 0)
-        y = crop_region.get("y", 0)
-        width = crop_region.get("width", 512)
-        height = crop_region.get("height", 512)
-
-        x = min(x, image.shape[2] - 1)
-        y = min(y, image.shape[1] - 1)
-        to_x = width + x
-        to_y = height + y
-        img = image[:,y:to_y, x:to_x, :]
-        return IO.NodeOutput(img)
-
-
-class BoundingBox(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="PrimitiveBoundingBox",
-            display_name="Bounding Box",
-            category="utils/primitive",
-            inputs=[
-                IO.Int.Input("x", default=0, min=0, max=MAX_RESOLUTION),
-                IO.Int.Input("y", default=0, min=0, max=MAX_RESOLUTION),
-                IO.Int.Input("width", default=512, min=1, max=MAX_RESOLUTION),
-                IO.Int.Input("height", default=512, min=1, max=MAX_RESOLUTION),
-            ],
-            outputs=[IO.BoundingBox.Output()],
-        )
-
-    @classmethod
-    def execute(cls, x, y, width, height) -> IO.NodeOutput:
-        return IO.NodeOutput({"x": x, "y": y, "width": width, "height": height})
-
-
 class RepeatImageBatch(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -684,8 +632,6 @@ class ImagesExtension(ComfyExtension):
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
         return [
             ImageCrop,
-            ImageCropV2,
-            BoundingBox,
             RepeatImageBatch,
             ImageFromBatch,
             ImageAddNoise,

execution.py

@@ -623,8 +623,6 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,
             logging.info("Memory summary: {}".format(comfy.model_management.debug_memory_summary()))
             logging.error("Got an OOM, unloading all loaded models.")
             comfy.model_management.unload_all_models()
-        elif isinstance(ex, RuntimeError) and ("mat1 and mat2 shapes" in str(ex)) and "Sampler" in class_type:
-            tips = "\n\nTIPS: If you have any \"Load CLIP\" or \"*CLIP Loader\" nodes in your workflow connected to this sampler node make sure the correct file(s) and type is selected."
 
         error_details = {
             "node_id": real_node_id,

nodes.py

@@ -2435,9 +2435,6 @@ async def init_builtin_extra_nodes():
         "nodes_lora_debug.py",
         "nodes_color.py",
         "nodes_toolkit.py",
-        "nodes_color_correct.py",
-        "nodes_color_balance.py",
-        "nodes_color_curves.py"
     ]
 
     import_failed = []