Merge e568474e29 into 89e4ea0175

comfy/cli_args.py

@@ -101,7 +101,6 @@ parser.add_argument("--preview-size", type=int, default=512, help="Sets the maxi
 cache_group = parser.add_mutually_exclusive_group()
 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.")
 
 attn_group = parser.add_mutually_exclusive_group()
 attn_group.add_argument("--use-split-cross-attention", action="store_true", help="Use the split cross attention optimization. Ignored when xformers is used.")

comfy/clip_vision.py

@@ -110,13 +110,9 @@ def load_clipvision_from_sd(sd, prefix="", convert_keys=False):
     elif "vision_model.encoder.layers.30.layer_norm1.weight" in sd:
         json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_h.json")
     elif "vision_model.encoder.layers.22.layer_norm1.weight" in sd:
-        embed_shape = sd["vision_model.embeddings.position_embedding.weight"].shape[0]
         if sd["vision_model.encoder.layers.0.layer_norm1.weight"].shape[0] == 1152:
-            if embed_shape == 729:
-                json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_siglip_384.json")
-            elif embed_shape == 1024:
-                json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_siglip_512.json")
-        elif embed_shape == 577:
+            json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_siglip_384.json")
+        elif sd["vision_model.embeddings.position_embedding.weight"].shape[0] == 577:
             if "multi_modal_projector.linear_1.bias" in sd:
                 json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_config_vitl_336_llava.json")
             else:

comfy/clip_vision_siglip_512.json

@@ -1,13 +0,0 @@
-{
-  "num_channels": 3,
-  "hidden_act": "gelu_pytorch_tanh",
-  "hidden_size": 1152,
-  "image_size": 512,
-  "intermediate_size": 4304,
-  "model_type": "siglip_vision_model",
-  "num_attention_heads": 16,
-  "num_hidden_layers": 27,
-  "patch_size": 16,
-  "image_mean": [0.5, 0.5, 0.5],
-  "image_std": [0.5, 0.5, 0.5]
-}

comfy/comfy_types/node_typing.py

@@ -102,13 +102,9 @@ class InputTypeOptions(TypedDict):
     default: bool | str | float | int | list | tuple
     """The default value of the widget"""
     defaultInput: bool
-    """@deprecated in v1.16 frontend. v1.16 frontend allows input socket and widget to co-exist.
-    - defaultInput on required inputs should be dropped.
-    - defaultInput on optional inputs should be replaced with forceInput.
-    Ref: https://github.com/Comfy-Org/ComfyUI_frontend/pull/3364
-    """
+    """Defaults to an input slot rather than a widget"""
     forceInput: bool
-    """Forces the input to be an input slot rather than a widget even a widget is available for the input type."""
+    """`defaultInput` and also don't allow converting to a widget"""
     lazy: bool
     """Declares that this input uses lazy evaluation"""
     rawLink: bool

comfy/lora_convert.py

@@ -1,5 +1,4 @@
 import torch
-import comfy.utils
 
 
 def convert_lora_bfl_control(sd): #BFL loras for Flux
@@ -12,13 +11,7 @@ def convert_lora_bfl_control(sd): #BFL loras for Flux
     return sd_out
 
 
-def convert_lora_wan_fun(sd): #Wan Fun loras
-    return comfy.utils.state_dict_prefix_replace(sd, {"lora_unet__": "lora_unet_"})
-
-
 def convert_lora(sd):
     if "img_in.lora_A.weight" in sd and "single_blocks.0.norm.key_norm.scale" in sd:
         return convert_lora_bfl_control(sd)
-    if "lora_unet__blocks_0_cross_attn_k.lora_down.weight" in sd:
-        return convert_lora_wan_fun(sd)
     return sd

comfy/patcher_extension.py

@@ -48,7 +48,6 @@ def get_all_callbacks(call_type: str, transformer_options: dict, is_model_option
 
 class WrappersMP:
     OUTER_SAMPLE = "outer_sample"
-    PREPARE_SAMPLING = "prepare_sampling"
     SAMPLER_SAMPLE = "sampler_sample"
     CALC_COND_BATCH = "calc_cond_batch"
     APPLY_MODEL = "apply_model"

comfy/sampler_helpers.py

@@ -106,13 +106,6 @@ def cleanup_additional_models(models):
 
 
 def prepare_sampling(model: ModelPatcher, noise_shape, conds, model_options=None):
-    executor = comfy.patcher_extension.WrapperExecutor.new_executor(
-        _prepare_sampling,
-        comfy.patcher_extension.get_all_wrappers(comfy.patcher_extension.WrappersMP.PREPARE_SAMPLING, model_options, is_model_options=True)
-    )
-    return executor.execute(model, noise_shape, conds, model_options=model_options)
-
-def _prepare_sampling(model: ModelPatcher, noise_shape, conds, model_options=None):
     real_model: BaseModel = None
     models, inference_memory = get_additional_models(conds, model.model_dtype())
     models += get_additional_models_from_model_options(model_options)

comfy_execution/caching.py

@@ -316,156 +316,3 @@ class LRUCache(BasicCache):
             self.children[cache_key].append(self.cache_key_set.get_data_key(child_id))
         return self
 
-
-class DependencyAwareCache(BasicCache):
-    """
-    A cache implementation that tracks dependencies between nodes and manages
-    their execution and caching accordingly. It extends the BasicCache class.
-    Nodes are removed from this cache once all of their descendants have been
-    executed.
-    """
-
-    def __init__(self, key_class):
-        """
-        Initialize the DependencyAwareCache.
-
-        Args:
-            key_class: The class used for generating cache keys.
-        """
-        super().__init__(key_class)
-        self.descendants = {}  # Maps node_id -> set of descendant node_ids
-        self.ancestors = {}    # Maps node_id -> set of ancestor node_ids
-        self.executed_nodes = set()  # Tracks nodes that have been executed
-
-    def set_prompt(self, dynprompt, node_ids, is_changed_cache):
-        """
-        Clear the entire cache and rebuild the dependency graph.
-
-        Args:
-            dynprompt: The dynamic prompt object containing node information.
-            node_ids: List of node IDs to initialize the cache for.
-            is_changed_cache: Flag indicating if the cache has changed.
-        """
-        # Clear all existing cache data
-        self.cache.clear()
-        self.subcaches.clear()
-        self.descendants.clear()
-        self.ancestors.clear()
-        self.executed_nodes.clear()
-
-        # Call the parent method to initialize the cache with the new prompt
-        super().set_prompt(dynprompt, node_ids, is_changed_cache)
-
-        # Rebuild the dependency graph
-        self._build_dependency_graph(dynprompt, node_ids)
-
-    def _build_dependency_graph(self, dynprompt, node_ids):
-        """
-        Build the dependency graph for all nodes.
-
-        Args:
-            dynprompt: The dynamic prompt object containing node information.
-            node_ids: List of node IDs to build the graph for.
-        """
-        self.descendants.clear()
-        self.ancestors.clear()
-        for node_id in node_ids:
-            self.descendants[node_id] = set()
-            self.ancestors[node_id] = set()
-
-        for node_id in node_ids:
-            inputs = dynprompt.get_node(node_id)["inputs"]
-            for input_data in inputs.values():
-                if is_link(input_data):  # Check if the input is a link to another node
-                    ancestor_id = input_data[0]
-                    self.descendants[ancestor_id].add(node_id)
-                    self.ancestors[node_id].add(ancestor_id)
-
-    def set(self, node_id, value):
-        """
-        Mark a node as executed and store its value in the cache.
-
-        Args:
-            node_id: The ID of the node to store.
-            value: The value to store for the node.
-        """
-        self._set_immediate(node_id, value)
-        self.executed_nodes.add(node_id)
-        self._cleanup_ancestors(node_id)
-
-    def get(self, node_id):
-        """
-        Retrieve the cached value for a node.
-
-        Args:
-            node_id: The ID of the node to retrieve.
-
-        Returns:
-            The cached value for the node.
-        """
-        return self._get_immediate(node_id)
-
-    def ensure_subcache_for(self, node_id, children_ids):
-        """
-        Ensure a subcache exists for a node and update dependencies.
-
-        Args:
-            node_id: The ID of the parent node.
-            children_ids: List of child node IDs to associate with the parent node.
-
-        Returns:
-            The subcache object for the node.
-        """
-        subcache = super()._ensure_subcache(node_id, children_ids)
-        for child_id in children_ids:
-            self.descendants[node_id].add(child_id)
-            self.ancestors[child_id].add(node_id)
-        return subcache
-
-    def _cleanup_ancestors(self, node_id):
-        """
-        Check if ancestors of a node can be removed from the cache.
-
-        Args:
-            node_id: The ID of the node whose ancestors are to be checked.
-        """
-        for ancestor_id in self.ancestors.get(node_id, []):
-            if ancestor_id in self.executed_nodes:
-                # Remove ancestor if all its descendants have been executed
-                if all(descendant in self.executed_nodes for descendant in self.descendants[ancestor_id]):
-                    self._remove_node(ancestor_id)
-
-    def _remove_node(self, node_id):
-        """
-        Remove a node from the cache.
-
-        Args:
-            node_id: The ID of the node to remove.
-        """
-        cache_key = self.cache_key_set.get_data_key(node_id)
-        if cache_key in self.cache:
-            del self.cache[cache_key]
-        subcache_key = self.cache_key_set.get_subcache_key(node_id)
-        if subcache_key in self.subcaches:
-            del self.subcaches[subcache_key]
-
-    def clean_unused(self):
-        """
-        Clean up unused nodes. This is a no-op for this cache implementation.
-        """
-        pass
-
-    def recursive_debug_dump(self):
-        """
-        Dump the cache and dependency graph for debugging.
-
-        Returns:
-            A list containing the cache state and dependency graph.
-        """
-        result = super().recursive_debug_dump()
-        result.append({
-            "descendants": self.descendants,
-            "ancestors": self.ancestors,
-            "executed_nodes": list(self.executed_nodes),
-        })
-        return result

comfy_extras/nodes_hunyuan3d.py

@@ -209,196 +209,6 @@ def voxel_to_mesh(voxels, threshold=0.5, device=None):
     vertices = torch.fliplr(vertices)
     return vertices, faces
 
-def voxel_to_mesh_surfnet(voxels, threshold=0.5, device=None):
-    if device is None:
-        device = torch.device("cpu")
-    voxels = voxels.to(device)
-
-    D, H, W = voxels.shape
-
-    padded = torch.nn.functional.pad(voxels, (1, 1, 1, 1, 1, 1), 'constant', 0)
-    z, y, x = torch.meshgrid(
-        torch.arange(D, device=device),
-        torch.arange(H, device=device),
-        torch.arange(W, device=device),
-        indexing='ij'
-    )
-    cell_positions = torch.stack([z.flatten(), y.flatten(), x.flatten()], dim=1)
-
-    corner_offsets = torch.tensor([
-        [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0],
-        [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]
-    ], device=device)
-
-    corner_values = torch.zeros((cell_positions.shape[0], 8), device=device)
-    for c, (dz, dy, dx) in enumerate(corner_offsets):
-        corner_values[:, c] = padded[
-            cell_positions[:, 0] + dz,
-            cell_positions[:, 1] + dy,
-            cell_positions[:, 2] + dx
-        ]
-
-    corner_signs = corner_values > threshold
-    has_inside = torch.any(corner_signs, dim=1)
-    has_outside = torch.any(~corner_signs, dim=1)
-    contains_surface = has_inside & has_outside
-
-    active_cells = cell_positions[contains_surface]
-    active_signs = corner_signs[contains_surface]
-    active_values = corner_values[contains_surface]
-
-    if active_cells.shape[0] == 0:
-        return torch.zeros((0, 3), device=device), torch.zeros((0, 3), dtype=torch.long, device=device)
-
-    edges = torch.tensor([
-        [0, 1], [0, 2], [0, 4], [1, 3],
-        [1, 5], [2, 3], [2, 6], [3, 7],
-        [4, 5], [4, 6], [5, 7], [6, 7]
-    ], device=device)
-
-    cell_vertices = {}
-    progress = comfy.utils.ProgressBar(100)
-
-    for edge_idx, (e1, e2) in enumerate(edges):
-        progress.update(1)
-        crossing = active_signs[:, e1] != active_signs[:, e2]
-        if not crossing.any():
-            continue
-
-        cell_indices = torch.nonzero(crossing, as_tuple=True)[0]
-
-        v1 = active_values[cell_indices, e1]
-        v2 = active_values[cell_indices, e2]
-
-        t = torch.zeros_like(v1, device=device)
-        denom = v2 - v1
-        valid = denom != 0
-        t[valid] = (threshold - v1[valid]) / denom[valid]
-        t[~valid] = 0.5
-
-        p1 = corner_offsets[e1].float()
-        p2 = corner_offsets[e2].float()
-
-        intersection = p1.unsqueeze(0) + t.unsqueeze(1) * (p2.unsqueeze(0) - p1.unsqueeze(0))
-
-        for i, point in zip(cell_indices.tolist(), intersection):
-            if i not in cell_vertices:
-                cell_vertices[i] = []
-            cell_vertices[i].append(point)
-
-    # Calculate the final vertices as the average of intersection points for each cell
-    vertices = []
-    vertex_lookup = {}
-
-    vert_progress_mod = round(len(cell_vertices)/50)
-
-    for i, points in cell_vertices.items():
-        if not i % vert_progress_mod:
-            progress.update(1)
-
-        if points:
-            vertex = torch.stack(points).mean(dim=0)
-            vertex = vertex + active_cells[i].float()
-            vertex_lookup[tuple(active_cells[i].tolist())] = len(vertices)
-            vertices.append(vertex)
-
-    if not vertices:
-        return torch.zeros((0, 3), device=device), torch.zeros((0, 3), dtype=torch.long, device=device)
-
-    final_vertices = torch.stack(vertices)
-
-    inside_corners_mask = active_signs
-    outside_corners_mask = ~active_signs
-
-    inside_counts = inside_corners_mask.sum(dim=1, keepdim=True).float()
-    outside_counts = outside_corners_mask.sum(dim=1, keepdim=True).float()
-
-    inside_pos = torch.zeros((active_cells.shape[0], 3), device=device)
-    outside_pos = torch.zeros((active_cells.shape[0], 3), device=device)
-
-    for i in range(8):
-        mask_inside = inside_corners_mask[:, i].unsqueeze(1)
-        mask_outside = outside_corners_mask[:, i].unsqueeze(1)
-        inside_pos += corner_offsets[i].float().unsqueeze(0) * mask_inside
-        outside_pos += corner_offsets[i].float().unsqueeze(0) * mask_outside
-
-    inside_pos /= inside_counts
-    outside_pos /= outside_counts
-    gradients = inside_pos - outside_pos
-
-    pos_dirs = torch.tensor([
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1]
-    ], device=device)
-
-    cross_products = [
-        torch.linalg.cross(pos_dirs[i].float(), pos_dirs[j].float())
-        for i in range(3) for j in range(i+1, 3)
-    ]
-
-    faces = []
-    all_keys = set(vertex_lookup.keys())
-
-    face_progress_mod = round(len(active_cells)/38*3)
-
-    for pair_idx, (i, j) in enumerate([(0,1), (0,2), (1,2)]):
-        dir_i = pos_dirs[i]
-        dir_j = pos_dirs[j]
-        cross_product = cross_products[pair_idx]
-
-        ni_positions = active_cells + dir_i
-        nj_positions = active_cells + dir_j
-        diag_positions = active_cells + dir_i + dir_j
-
-        alignments = torch.matmul(gradients, cross_product)
-
-        valid_quads = []
-        quad_indices = []
-
-        for idx, active_cell in enumerate(active_cells):
-            if not idx % face_progress_mod:
-                progress.update(1)
-            cell_key = tuple(active_cell.tolist())
-            ni_key = tuple(ni_positions[idx].tolist())
-            nj_key = tuple(nj_positions[idx].tolist())
-            diag_key = tuple(diag_positions[idx].tolist())
-
-            if cell_key in all_keys and ni_key in all_keys and nj_key in all_keys and diag_key in all_keys:
-                v0 = vertex_lookup[cell_key]
-                v1 = vertex_lookup[ni_key]
-                v2 = vertex_lookup[nj_key]
-                v3 = vertex_lookup[diag_key]
-
-                valid_quads.append((v0, v1, v2, v3))
-                quad_indices.append(idx)
-
-        for q_idx, (v0, v1, v2, v3) in enumerate(valid_quads):
-            cell_idx = quad_indices[q_idx]
-            if alignments[cell_idx] > 0:
-                faces.append(torch.tensor([v0, v1, v3], device=device, dtype=torch.long))
-                faces.append(torch.tensor([v0, v3, v2], device=device, dtype=torch.long))
-            else:
-                faces.append(torch.tensor([v0, v3, v1], device=device, dtype=torch.long))
-                faces.append(torch.tensor([v0, v2, v3], device=device, dtype=torch.long))
-
-    if faces:
-        faces = torch.stack(faces)
-    else:
-        faces = torch.zeros((0, 3), dtype=torch.long, device=device)
-
-    v_min = 0
-    v_max = max(D, H, W)
-
-    final_vertices = final_vertices - (v_min + v_max) / 2
-
-    scale = (v_max - v_min) / 2
-    if scale > 0:
-        final_vertices = final_vertices / scale
-
-    final_vertices = torch.fliplr(final_vertices)
-
-    return final_vertices, faces
 
 class MESH:
     def __init__(self, vertices, faces):
@@ -427,34 +237,6 @@ class VoxelToMeshBasic:
 
         return (MESH(torch.stack(vertices), torch.stack(faces)), )
 
-class VoxelToMesh:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {"voxel": ("VOXEL", ),
-                             "algorithm": (["surface net", "basic"], ),
-                             "threshold": ("FLOAT", {"default": 0.6, "min": -1.0, "max": 1.0, "step": 0.01}),
-                             }}
-    RETURN_TYPES = ("MESH",)
-    FUNCTION = "decode"
-
-    CATEGORY = "3d"
-
-    def decode(self, voxel, algorithm, threshold):
-        vertices = []
-        faces = []
-
-        if algorithm == "basic":
-            mesh_function = voxel_to_mesh
-        elif algorithm == "surface net":
-            mesh_function = voxel_to_mesh_surfnet
-
-        for x in voxel.data:
-            v, f = mesh_function(x, threshold=threshold, device=None)
-            vertices.append(v)
-            faces.append(f)
-
-        return (MESH(torch.stack(vertices), torch.stack(faces)), )
-
 
 def save_glb(vertices, faces, filepath, metadata=None):
     """
@@ -629,6 +411,5 @@ NODE_CLASS_MAPPINGS = {
     "Hunyuan3Dv2ConditioningMultiView": Hunyuan3Dv2ConditioningMultiView,
     "VAEDecodeHunyuan3D": VAEDecodeHunyuan3D,
     "VoxelToMeshBasic": VoxelToMeshBasic,
-    "VoxelToMesh": VoxelToMesh,
     "SaveGLB": SaveGLB,
 }

execution.py

@@ -15,7 +15,7 @@ import nodes
 import comfy.model_management
 from comfy_execution.graph import get_input_info, ExecutionList, DynamicPrompt, ExecutionBlocker
 from comfy_execution.graph_utils import is_link, GraphBuilder
-from comfy_execution.caching import HierarchicalCache, LRUCache, DependencyAwareCache, CacheKeySetInputSignature, CacheKeySetID
+from comfy_execution.caching import HierarchicalCache, LRUCache, CacheKeySetInputSignature, CacheKeySetID
 from comfy_execution.validation import validate_node_input
 
 class ExecutionResult(Enum):
@@ -59,45 +59,27 @@ class IsChangedCache:
             self.is_changed[node_id] = node["is_changed"]
         return self.is_changed[node_id]
 
-
-class CacheType(Enum):
-    CLASSIC = 0
-    LRU = 1
-    DEPENDENCY_AWARE = 2
-
-
 class CacheSet:
-    def __init__(self, cache_type=None, cache_size=None):
-        if cache_type == CacheType.DEPENDENCY_AWARE:
-            self.init_dependency_aware_cache()
-            logging.info("Disabling intermediate node cache.")
-        elif cache_type == CacheType.LRU:
-            if cache_size is None:
-                cache_size = 0
-            self.init_lru_cache(cache_size)
-            logging.info("Using LRU cache")
-        else:
+    def __init__(self, lru_size=None):
+        if lru_size is None or lru_size == 0:
             self.init_classic_cache()
-
+        else:
+            self.init_lru_cache(lru_size)
         self.all = [self.outputs, self.ui, self.objects]
 
+    # Useful for those with ample RAM/VRAM -- allows experimenting without
+    # blowing away the cache every time
+    def init_lru_cache(self, cache_size):
+        self.outputs = LRUCache(CacheKeySetInputSignature, max_size=cache_size)
+        self.ui = LRUCache(CacheKeySetInputSignature, max_size=cache_size)
+        self.objects = HierarchicalCache(CacheKeySetID)
+
     # Performs like the old cache -- dump data ASAP
     def init_classic_cache(self):
         self.outputs = HierarchicalCache(CacheKeySetInputSignature)
         self.ui = HierarchicalCache(CacheKeySetInputSignature)
         self.objects = HierarchicalCache(CacheKeySetID)
 
-    def init_lru_cache(self, cache_size):
-        self.outputs = LRUCache(CacheKeySetInputSignature, max_size=cache_size)
-        self.ui = LRUCache(CacheKeySetInputSignature, max_size=cache_size)
-        self.objects = HierarchicalCache(CacheKeySetID)
-
-    # only hold cached items while the decendents have not executed
-    def init_dependency_aware_cache(self):
-        self.outputs = DependencyAwareCache(CacheKeySetInputSignature)
-        self.ui = DependencyAwareCache(CacheKeySetInputSignature)
-        self.objects = DependencyAwareCache(CacheKeySetID)
-
     def recursive_debug_dump(self):
         result = {
             "outputs": self.outputs.recursive_debug_dump(),
@@ -432,14 +414,13 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, promp
     return (ExecutionResult.SUCCESS, None, None)
 
 class PromptExecutor:
-    def __init__(self, server, cache_type=False, cache_size=None):
-        self.cache_size = cache_size
-        self.cache_type = cache_type
+    def __init__(self, server, lru_size=None):
+        self.lru_size = lru_size
         self.server = server
         self.reset()
 
     def reset(self):
-        self.caches = CacheSet(cache_type=self.cache_type, cache_size=self.cache_size)
+        self.caches = CacheSet(self.lru_size)
         self.status_messages = []
         self.success = True
 
@@ -794,7 +775,7 @@ def validate_prompt(prompt):
                 "details": f"Node ID '#{x}'",
                 "extra_info": {}
             }
-            return (False, error, [], {})
+            return (False, error, [], [])
 
         class_type = prompt[x]['class_type']
         class_ = nodes.NODE_CLASS_MAPPINGS.get(class_type, None)
@@ -805,7 +786,7 @@ def validate_prompt(prompt):
                 "details": f"Node ID '#{x}'",
                 "extra_info": {}
             }
-            return (False, error, [], {})
+            return (False, error, [], [])
 
         if hasattr(class_, 'OUTPUT_NODE') and class_.OUTPUT_NODE is True:
             outputs.add(x)
@@ -817,7 +798,7 @@ def validate_prompt(prompt):
             "details": "",
             "extra_info": {}
         }
-        return (False, error, [], {})
+        return (False, error, [], [])
 
     good_outputs = set()
     errors = []

main.py

@@ -156,13 +156,7 @@ def cuda_malloc_warning():
 
 def prompt_worker(q, server_instance):
     current_time: float = 0.0
-    cache_type = execution.CacheType.CLASSIC
-    if args.cache_lru > 0:
-        cache_type = execution.CacheType.LRU
-    elif args.cache_none:
-        cache_type = execution.CacheType.DEPENDENCY_AWARE
-
-    e = execution.PromptExecutor(server_instance, cache_type=cache_type, cache_size=args.cache_lru)
+    e = execution.PromptExecutor(server_instance, lru_size=args.cache_lru)
     last_gc_collect = 0
     need_gc = False
     gc_collect_interval = 10.0

nodes.py

@@ -786,8 +786,6 @@ class ControlNetLoader:
     def load_controlnet(self, control_net_name):
         controlnet_path = folder_paths.get_full_path_or_raise("controlnet", control_net_name)
         controlnet = comfy.controlnet.load_controlnet(controlnet_path)
-        if controlnet is None:
-            raise RuntimeError("ERROR: controlnet file is invalid and does not contain a valid controlnet model.")
         return (controlnet,)
 
 class DiffControlNetLoader:
@@ -1008,8 +1006,6 @@ class CLIPVisionLoader:
     def load_clip(self, clip_name):
         clip_path = folder_paths.get_full_path_or_raise("clip_vision", clip_name)
         clip_vision = comfy.clip_vision.load(clip_path)
-        if clip_vision is None:
-            raise RuntimeError("ERROR: clip vision file is invalid and does not contain a valid vision model.")
         return (clip_vision,)
 
 class CLIPVisionEncode:
@@ -1692,9 +1688,6 @@ class LoadImage:
             if 'A' in i.getbands():
                 mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
                 mask = 1. - torch.from_numpy(mask)
-            elif i.mode == 'P' and 'transparency' in i.info:
-                mask = np.array(i.convert('RGBA').getchannel('A')).astype(np.float32) / 255.0
-                mask = 1. - torch.from_numpy(mask)
             else:
                 mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
             output_images.append(image)
@@ -2130,25 +2123,21 @@ def get_module_name(module_path: str) -> str:
 
 
 def load_custom_node(module_path: str, ignore=set(), module_parent="custom_nodes") -> bool:
-    module_name = get_module_name(module_path)
+    module_name = os.path.basename(module_path)
     if os.path.isfile(module_path):
         sp = os.path.splitext(module_path)
         module_name = sp[0]
-        sys_module_name = module_name
-    elif os.path.isdir(module_path):
-        sys_module_name = module_path.replace(".", "_x_")
-
     try:
         logging.debug("Trying to load custom node {}".format(module_path))
         if os.path.isfile(module_path):
-            module_spec = importlib.util.spec_from_file_location(sys_module_name, module_path)
+            module_spec = importlib.util.spec_from_file_location(module_name, module_path)
             module_dir = os.path.split(module_path)[0]
         else:
-            module_spec = importlib.util.spec_from_file_location(sys_module_name, os.path.join(module_path, "__init__.py"))
+            module_spec = importlib.util.spec_from_file_location(module_name, os.path.join(module_path, "__init__.py"))
             module_dir = module_path
 
         module = importlib.util.module_from_spec(module_spec)
-        sys.modules[sys_module_name] = module
+        sys.modules[module_name] = module
         module_spec.loader.exec_module(module)
 
         LOADED_MODULE_DIRS[module_name] = os.path.abspath(module_dir)

requirements.txt

@@ -1,4 +1,4 @@
-comfyui-frontend-package==1.15.13
+comfyui-frontend-package==1.14.6
 torch
 torchsde
 torchvision

server.py

@@ -48,7 +48,7 @@ async def send_socket_catch_exception(function, message):
 @web.middleware
 async def cache_control(request: web.Request, handler):
     response: web.Response = await handler(request)
-    if request.path.endswith('.js') or request.path.endswith('.css') or request.path.endswith('index.json'):
+    if request.path.endswith('.js') or request.path.endswith('.css'):
         response.headers.setdefault('Cache-Control', 'no-cache')
     return response
 
@@ -657,13 +657,7 @@ class PromptServer():
                     logging.warning("invalid prompt: {}".format(valid[1]))
                     return web.json_response({"error": valid[1], "node_errors": valid[3]}, status=400)
             else:
-                error = {
-                    "type": "no_prompt",
-                    "message": "No prompt provided",
-                    "details": "No prompt provided",
-                    "extra_info": {}
-                }
-                return web.json_response({"error": error, "node_errors": {}}, status=400)
+                return web.json_response({"error": "no prompt", "node_errors": []}, status=400)
 
         @routes.post("/queue")
         async def post_queue(request):