import torch import folder_paths from pathlib import Path from nodes import NODE_CLASS_MAPPINGS from .device_utils import get_device_list, force_full_system_cleanup class DeviceSelectorMultiGPU: @classmethod def INPUT_TYPES(s): devices = get_device_list() return { "required": { "device": (devices, {"default": devices[1] if len(devices) > 1 else devices[0]}) } } RETURN_TYPES = (get_device_list(),) RETURN_NAMES = ("device",) FUNCTION = "select_device" CATEGORY = "multigpu" def select_device(self, device): return (device,) class HunyuanVideoEmbeddingsAdapter: @classmethod def INPUT_TYPES(s): return { "required": { "hyvid_embeds": ("HYVIDEMBEDS",), } } RETURN_TYPES = ("CONDITIONING",) FUNCTION = "adapt_embeddings" CATEGORY = "multigpu" def adapt_embeddings(self, hyvid_embeds): cond = hyvid_embeds["prompt_embeds"] pooled_dict = { "pooled_output": hyvid_embeds["prompt_embeds_2"], "cross_attn": hyvid_embeds["prompt_embeds"], "attention_mask": hyvid_embeds["attention_mask"], } if hyvid_embeds["attention_mask_2"] is not None: pooled_dict["attention_mask_controlnet"] = hyvid_embeds["attention_mask_2"] if hyvid_embeds["cfg"] is not None: pooled_dict["guidance"] = float(hyvid_embeds["cfg"]) pooled_dict["start_percent"] = float(hyvid_embeds["start_percent"]) if hyvid_embeds["start_percent"] is not None else 0.0 pooled_dict["end_percent"] = float(hyvid_embeds["end_percent"]) if hyvid_embeds["end_percent"] is not None else 1.0 return ([[cond, pooled_dict]],) class UnetLoaderGGUF: @classmethod def INPUT_TYPES(s): unet_names = [x for x in folder_paths.get_filename_list("unet_gguf")] return { "required": { "unet_name": (unet_names,), } } RETURN_TYPES = ("MODEL",) FUNCTION = "load_unet" CATEGORY = "bootleg" TITLE = "Unet Loader (GGUF)" def load_unet(self, unet_name, dequant_dtype=None, patch_dtype=None, patch_on_device=None): original_loader = NODE_CLASS_MAPPINGS["UnetLoaderGGUF"]() return original_loader.load_unet(unet_name, dequant_dtype, patch_dtype, patch_on_device) class UnetLoaderGGUFAdvanced(UnetLoaderGGUF): @classmethod def INPUT_TYPES(s): unet_names = [x for x in folder_paths.get_filename_list("unet_gguf")] return { "required": { "unet_name": (unet_names,), "dequant_dtype": (["default", "target", "float32", "float16", "bfloat16"], {"default": "default"}), "patch_dtype": (["default", "target", "float32", "float16", "bfloat16"], {"default": "default"}), "patch_on_device": ("BOOLEAN", {"default": False}), } } TITLE = "Unet Loader (GGUF/Advanced)" class CLIPLoaderGGUF: @classmethod def INPUT_TYPES(s): import nodes base = nodes.CLIPLoader.INPUT_TYPES() return { "required": { "clip_name": (s.get_filename_list(),), "type": base["required"]["type"], } } RETURN_TYPES = ("CLIP",) FUNCTION = "load_clip" CATEGORY = "bootleg" TITLE = "CLIPLoader (GGUF)" @classmethod def get_filename_list(s): files = [] files += folder_paths.get_filename_list("clip") files += folder_paths.get_filename_list("clip_gguf") return sorted(files) def load_data(self, ckpt_paths): original_loader = NODE_CLASS_MAPPINGS["CLIPLoaderGGUF"]() return original_loader.load_data(ckpt_paths) def load_patcher(self, clip_paths, clip_type, clip_data): original_loader = NODE_CLASS_MAPPINGS["CLIPLoaderGGUF"]() return original_loader.load_patcher(clip_paths, clip_type, clip_data) def load_clip(self, clip_name, type="stable_diffusion", device=None): original_loader = NODE_CLASS_MAPPINGS["CLIPLoaderGGUF"]() return original_loader.load_clip(clip_name, type) class DualCLIPLoaderGGUF(CLIPLoaderGGUF): @classmethod def INPUT_TYPES(s): import nodes base = nodes.DualCLIPLoader.INPUT_TYPES() file_options = (s.get_filename_list(), ) return { "required": { "clip_name1": file_options, "clip_name2": file_options, "type": base["required"]["type"], } } TITLE = "DualCLIPLoader (GGUF)" def load_clip(self, clip_name1, clip_name2, type, device=None): original_loader = NODE_CLASS_MAPPINGS["DualCLIPLoaderGGUF"]() clip = original_loader.load_clip(clip_name1, clip_name2, type) clip[0].patcher.load(force_patch_weights=True) return clip class TripleCLIPLoaderGGUF(CLIPLoaderGGUF): @classmethod def INPUT_TYPES(s): file_options = (s.get_filename_list(), ) return { "required": { "clip_name1": file_options, "clip_name2": file_options, "clip_name3": file_options, } } TITLE = "TripleCLIPLoader (GGUF)" def load_clip(self, clip_name1, clip_name2, clip_name3, type="sd3"): original_loader = NODE_CLASS_MAPPINGS["TripleCLIPLoaderGGUF"]() return original_loader.load_clip(clip_name1, clip_name2, clip_name3, type) class QuadrupleCLIPLoaderGGUF(CLIPLoaderGGUF): @classmethod def INPUT_TYPES(s): file_options = (s.get_filename_list(), ) return { "required": { "clip_name1": file_options, "clip_name2": file_options, "clip_name3": file_options, "clip_name4": file_options, } } TITLE = "QuadrupleCLIPLoader (GGUF)" def load_clip(self, clip_name1, clip_name2, clip_name3, clip_name4, type="stable_diffusion"): original_loader = NODE_CLASS_MAPPINGS["QuadrupleCLIPLoaderGGUF"]() return original_loader.load_clip(clip_name1, clip_name2, clip_name3, clip_name4, type) class LTXVLoader: @classmethod def INPUT_TYPES(s): return { "required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), {"tooltip": "The name of the checkpoint (model) to load."}), "dtype": (["bfloat16", "float32"], {"default": "bfloat16"}) } } RETURN_TYPES = ("MODEL", "VAE") RETURN_NAMES = ("model", "vae") FUNCTION = "load" CATEGORY = "lightricks/LTXV" TITLE = "LTXV Loader" OUTPUT_NODE = False def load(self, ckpt_name, dtype): original_loader = NODE_CLASS_MAPPINGS["LTXVLoader"]() return original_loader.load(ckpt_name, dtype) def _load_unet(self, load_device, offload_device, weights, num_latent_channels, dtype, config=None ): original_loader = NODE_CLASS_MAPPINGS["LTXVLoader"]() return original_loader._load_unet(load_device, offload_device, weights, num_latent_channels, dtype, config=None ) def _load_vae(self, weights, config=None): original_loader = NODE_CLASS_MAPPINGS["LTXVLoader"]() return original_loader._load_vae(weights, config=None) class Florence2ModelLoader: @classmethod def INPUT_TYPES(s): return {"required": { "model": ([item.name for item in Path(folder_paths.models_dir, "LLM").iterdir() if item.is_dir()], {"tooltip": "models are expected to be in Comfyui/models/LLM folder"}), "precision": (['fp16','bf16','fp32'],), "attention": ( [ 'flash_attention_2', 'sdpa', 'eager'], { "default": 'sdpa' }), }, "optional": { "lora": ("PEFTLORA",), } } RETURN_TYPES = ("FL2MODEL",) RETURN_NAMES = ("florence2_model",) FUNCTION = "loadmodel" CATEGORY = "Florence2" def loadmodel(self, model, precision, attention, lora=None): original_loader = NODE_CLASS_MAPPINGS["Florence2ModelLoader"]() return original_loader.loadmodel(model, precision, attention, lora) class DownloadAndLoadFlorence2Model: @classmethod def INPUT_TYPES(s): return {"required": { "model": ( [ 'microsoft/Florence-2-base', 'microsoft/Florence-2-base-ft', 'microsoft/Florence-2-large', 'microsoft/Florence-2-large-ft', 'HuggingFaceM4/Florence-2-DocVQA', 'thwri/CogFlorence-2.1-Large', 'thwri/CogFlorence-2.2-Large', 'gokaygokay/Florence-2-SD3-Captioner', 'gokaygokay/Florence-2-Flux-Large', 'MiaoshouAI/Florence-2-base-PromptGen-v1.5', 'MiaoshouAI/Florence-2-large-PromptGen-v1.5', 'MiaoshouAI/Florence-2-base-PromptGen-v2.0', 'MiaoshouAI/Florence-2-large-PromptGen-v2.0' ], { "default": 'microsoft/Florence-2-base' }), "precision": ([ 'fp16','bf16','fp32'], { "default": 'fp16' }), "attention": ( [ 'flash_attention_2', 'sdpa', 'eager'], { "default": 'sdpa' }), }, "optional": { "lora": ("PEFTLORA",), } } RETURN_TYPES = ("FL2MODEL",) RETURN_NAMES = ("florence2_model",) FUNCTION = "loadmodel" CATEGORY = "Florence2" def loadmodel(self, model, precision, attention, lora=None): original_loader = NODE_CLASS_MAPPINGS["DownloadAndLoadFlorence2Model"]() return original_loader.loadmodel(model, precision, attention, lora) class CheckpointLoaderNF4: @classmethod def INPUT_TYPES(s): return {"required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ), }} RETURN_TYPES = ("MODEL", "CLIP", "VAE") FUNCTION = "load_checkpoint" CATEGORY = "loaders" def load_checkpoint(self, ckpt_name): original_loader = NODE_CLASS_MAPPINGS["CheckpointLoaderNF4"]() return original_loader.load_checkpoint(ckpt_name) class LoadFluxControlNet: @classmethod def INPUT_TYPES(s): return {"required": {"model_name": (["flux-dev", "flux-dev-fp8", "flux-schnell"],), "controlnet_path": (folder_paths.get_filename_list("xlabs_controlnets"), ), }} RETURN_TYPES = ("FluxControlNet",) RETURN_NAMES = ("ControlNet",) FUNCTION = "loadmodel" CATEGORY = "XLabsNodes" def loadmodel(self, model_name, controlnet_path): original_loader = NODE_CLASS_MAPPINGS["LoadFluxControlNet"]() return original_loader.loadmodel(model_name, controlnet_path) class MMAudioModelLoader: @classmethod def INPUT_TYPES(s): return { "required": { "mmaudio_model": (folder_paths.get_filename_list("mmaudio"), {"tooltip": "These models are loaded from the 'ComfyUI/models/mmaudio' -folder",}), "base_precision": (["fp16", "fp32", "bf16"], {"default": "fp16"}), }, } RETURN_TYPES = ("MMAUDIO_MODEL",) RETURN_NAMES = ("mmaudio_model", ) FUNCTION = "loadmodel" CATEGORY = "MMAudio" def loadmodel(self, mmaudio_model, base_precision): original_loader = NODE_CLASS_MAPPINGS["MMAudioModelLoader"]() return original_loader.loadmodel(mmaudio_model, base_precision) class MMAudioFeatureUtilsLoader: @classmethod def INPUT_TYPES(s): return { "required": { "vae_model": (folder_paths.get_filename_list("mmaudio"), {"tooltip": "These models are loaded from 'ComfyUI/models/mmaudio'"}), "synchformer_model": (folder_paths.get_filename_list("mmaudio"), {"tooltip": "These models are loaded from 'ComfyUI/models/mmaudio'"}), "clip_model": (folder_paths.get_filename_list("mmaudio"), {"tooltip": "These models are loaded from 'ComfyUI/models/mmaudio'"}), }, "optional": { "bigvgan_vocoder_model": ("VOCODER_MODEL", {"tooltip": "These models are loaded from 'ComfyUI/models/mmaudio'"}), "mode": (["16k", "44k"], {"default": "44k"}), "precision": (["fp16", "fp32", "bf16"], {"default": "fp16"} ), } } RETURN_TYPES = ("MMAUDIO_FEATUREUTILS",) RETURN_NAMES = ("mmaudio_featureutils", ) FUNCTION = "loadmodel" CATEGORY = "MMAudio" def loadmodel(self, vae_model, precision, synchformer_model, clip_model, mode, bigvgan_vocoder_model=None): original_loader = NODE_CLASS_MAPPINGS["MMAudioFeatureUtilsLoader"]() return original_loader.loadmodel(vae_model, precision, synchformer_model, clip_model, mode, bigvgan_vocoder_model) class MMAudioSampler: @classmethod def INPUT_TYPES(s): return { "required": { "mmaudio_model": ("MMAUDIO_MODEL",), "feature_utils": ("MMAUDIO_FEATUREUTILS",), "duration": ("FLOAT", {"default": 8, "step": 0.01, "tooltip": "Duration of the audio in seconds"}), "steps": ("INT", {"default": 25, "step": 1, "tooltip": "Number of steps to interpolate"}), "cfg": ("FLOAT", {"default": 4.5, "step": 0.1, "tooltip": "Strength of the conditioning"}), "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), "prompt": ("STRING", {"default": "", "multiline": True} ), "negative_prompt": ("STRING", {"default": "", "multiline": True} ), "mask_away_clip": ("BOOLEAN", {"default": False, "tooltip": "If true, the clip video will be masked away"}), "force_offload": ("BOOLEAN", {"default": True, "tooltip": "If true, the model will be offloaded to the offload device"}), }, "optional": { "images": ("IMAGE",), }, } RETURN_TYPES = ("AUDIO",) RETURN_NAMES = ("audio", ) FUNCTION = "sample" CATEGORY = "MMAudio" def sample(self, mmaudio_model, seed, feature_utils, duration, steps, cfg, prompt, negative_prompt, mask_away_clip, force_offload, images=None): original_loader = NODE_CLASS_MAPPINGS["MMAudioSampler"]() return original_loader.sample(mmaudio_model, seed, feature_utils, duration, steps, cfg, prompt, negative_prompt, mask_away_clip, force_offload, images) class PulidModelLoader: @classmethod def INPUT_TYPES(s): return {"required": { "pulid_file": (folder_paths.get_filename_list("pulid"), )}} RETURN_TYPES = ("PULID",) FUNCTION = "load_model" CATEGORY = "pulid" def load_model(self, pulid_file): original_loader = NODE_CLASS_MAPPINGS["PulidModelLoader"]() return original_loader.load_model(pulid_file) class PulidInsightFaceLoader: @classmethod def INPUT_TYPES(s): return { "required": { "provider": (["CPU", "CUDA", "ROCM", "CoreML"], ), }, } RETURN_TYPES = ("FACEANALYSIS",) FUNCTION = "load_insightface" CATEGORY = "pulid" def load_insightface(self, provider): original_loader = NODE_CLASS_MAPPINGS["PulidInsightFaceLoader"]() return original_loader.load_insightface(provider) class PulidEvaClipLoader: @classmethod def INPUT_TYPES(s): return { "required": {}, } RETURN_TYPES = ("EVA_CLIP",) FUNCTION = "load_eva_clip" CATEGORY = "pulid" def load_eva_clip(self): original_loader = NODE_CLASS_MAPPINGS["PulidEvaClipLoader"]() return original_loader.load_eva_clip() class HyVideoModelLoader: @classmethod def INPUT_TYPES(s): return { "required": { "model": (folder_paths.get_filename_list("diffusion_models"), {"tooltip": "These models are loaded from the 'ComfyUI/models/diffusion_models' -folder",}), "base_precision": (["fp32", "bf16"], {"default": "bf16"}), "quantization": (['disabled', 'fp8_e4m3fn', 'fp8_e4m3fn_fast', 'fp8_scaled', 'torchao_fp8dq', "torchao_fp8dqrow", "torchao_int8dq", "torchao_fp6", "torchao_int4", "torchao_int8"], {"default": 'disabled', "tooltip": "optional quantization method"}), "load_device": (["main_device"], {"default": "main_device"}), }, "optional": { "attention_mode": ([ "sdpa", "flash_attn_varlen", "sageattn_varlen", "comfy", ], {"default": "flash_attn"}), "compile_args": ("COMPILEARGS", ), "block_swap_args": ("BLOCKSWAPARGS", ), "lora": ("HYVIDLORA", {"default": None}), "auto_cpu_offload": ("BOOLEAN", {"default": False, "tooltip": "Enable auto offloading for reduced VRAM usage, implementation from DiffSynth-Studio, slightly different from block swapping and uses even less VRAM, but can be slower as you can't define how much VRAM to use"}), } } RETURN_TYPES = ("HYVIDEOMODEL",) RETURN_NAMES = ("model", ) FUNCTION = "loadmodel" CATEGORY = "HunyuanVideoWrapper" def loadmodel(self, model, base_precision, load_device, quantization, compile_args=None, attention_mode="sdpa", block_swap_args=None, lora=None, auto_cpu_offload=False): original_loader = NODE_CLASS_MAPPINGS["HyVideoModelLoader"]() return original_loader.loadmodel(model, base_precision, load_device, quantization, compile_args, attention_mode, block_swap_args, lora, auto_cpu_offload) class HyVideoVAELoader: @classmethod def INPUT_TYPES(s): return { "required": { "model_name": (folder_paths.get_filename_list("vae"), {"tooltip": "These models are loaded from 'ComfyUI/models/vae'"}), }, "optional": { "precision": (["fp16", "fp32", "bf16"], {"default": "bf16"} ), "compile_args":("COMPILEARGS", ), } } RETURN_TYPES = ("VAE",) RETURN_NAMES = ("vae", ) FUNCTION = "loadmodel" CATEGORY = "HunyuanVideoWrapper" DESCRIPTION = "Loads Hunyuan VAE model from 'ComfyUI/models/vae'" def loadmodel(self, model_name, precision, compile_args=None): original_loader = NODE_CLASS_MAPPINGS["HyVideoVAELoader"]() return original_loader.loadmodel(model_name, precision, compile_args) class DownloadAndLoadHyVideoTextEncoder: @classmethod def INPUT_TYPES(s): return { "required": { "llm_model": (["Kijai/llava-llama-3-8b-text-encoder-tokenizer","xtuner/llava-llama-3-8b-v1_1-transformers"],), "clip_model": (["disabled","openai/clip-vit-large-patch14",],), "precision": (["fp16", "fp32", "bf16"], {"default": "bf16"} ), }, "optional": { "apply_final_norm": ("BOOLEAN", {"default": False}), "hidden_state_skip_layer": ("INT", {"default": 2}), "quantization": (['disabled', 'bnb_nf4', "fp8_e4m3fn"], {"default": 'disabled'}), } } RETURN_TYPES = ("HYVIDTEXTENCODER",) RETURN_NAMES = ("hyvid_text_encoder", ) FUNCTION = "loadmodel" CATEGORY = "HunyuanVideoWrapper" DESCRIPTION = "Loads Hunyuan text_encoder model from 'ComfyUI/models/LLM'" def loadmodel(self, llm_model, clip_model, precision, apply_final_norm=False, hidden_state_skip_layer=2, quantization="disabled"): original_loader = NODE_CLASS_MAPPINGS["DownloadAndLoadHyVideoTextEncoder"]() return original_loader.loadmodel(llm_model, clip_model, precision, apply_final_norm, hidden_state_skip_layer, quantization) class FullCleanupMultiGPU: @classmethod def INPUT_TYPES(s): return { "required": { "image": ("IMAGE",), "reason": ("STRING", {"default": "inline_node", "multiline": False}), }, "optional": { "force": ("BOOLEAN", {"default": True}), } } RETURN_TYPES = ("IMAGE",) RETURN_NAMES = ("image",) FUNCTION = "cleanup" CATEGORY = "multigpu/maintenance" TITLE = "Full System Cleanup (MultiGPU)" def cleanup(self, image, reason, force=True): """ Trigger the full system cleanup to match ComfyUI's 'Free model and node cache'. Passthroughs the input image unchanged; summary is logged via MultiGPU logger. """ _ = force_full_system_cleanup(reason=reason, force=force) return (image,)