diff --git a/.ci/update_windows/update.py b/.ci/update_windows/update.py index 6a04e5e16..d337457c0 100755 --- a/.ci/update_windows/update.py +++ b/.ci/update_windows/update.py @@ -47,7 +47,7 @@ def pull(repo, remote_name='origin', branch='master'): pygit2.option(pygit2.GIT_OPT_SET_OWNER_VALIDATION, 0) repo_path = str(sys.argv[1]) repo = pygit2.Repository(repo_path) -ident = pygit2.Signature('comfyui', 'comfy@ui') +ident = pygit2.Signature('comfyui', 'seap@ui') try: print("stashing current changes") repo.stash(ident) diff --git a/app/app_settings.py b/app/app_settings.py index 8c6edc56c..176f0a85b 100644 --- a/app/app_settings.py +++ b/app/app_settings.py @@ -9,7 +9,7 @@ class AppSettings(): def get_settings(self, request): file = self.user_manager.get_request_user_filepath( - request, "comfy.settings.json") + request, "seap.settings.json") if os.path.isfile(file): with open(file) as f: return json.load(f) @@ -18,7 +18,7 @@ class AppSettings(): def save_settings(self, request, settings): file = self.user_manager.get_request_user_filepath( - request, "comfy.settings.json") + request, "seap.settings.json") with open(file, "w") as f: f.write(json.dumps(settings, indent=4)) diff --git a/app/frontend_management.py b/app/frontend_management.py index 9c832e46d..f4a6b4c55 100644 --- a/app/frontend_management.py +++ b/app/frontend_management.py @@ -12,7 +12,7 @@ from typing import TypedDict, Optional import requests from typing_extensions import NotRequired -from comfy.cli_args import DEFAULT_VERSION_STRING +from seap.cli_args import DEFAULT_VERSION_STRING REQUEST_TIMEOUT = 10 # seconds diff --git a/app/user_manager.py b/app/user_manager.py index 208178444..5b97e7c46 100644 --- a/app/user_manager.py +++ b/app/user_manager.py @@ -6,7 +6,7 @@ import glob import shutil from aiohttp import web from urllib import parse -from comfy.cli_args import args +from seap.cli_args import args import folder_paths from .app_settings import AppSettings @@ -38,8 +38,8 @@ class UserManager(): def get_request_user_id(self, request): user = "default" - if args.multi_user and "comfy-user" in request.headers: - user = request.headers["comfy-user"] + if args.multi_user and "seap-user" in request.headers: + user = request.headers["seap-user"] if user not in self.users: raise KeyError("Unknown user: " + user) diff --git a/cuda_malloc.py b/cuda_malloc.py index eb2857c5f..76a511cfc 100644 --- a/cuda_malloc.py +++ b/cuda_malloc.py @@ -1,6 +1,6 @@ import os import importlib.util -from comfy.cli_args import args +from seap.cli_args import args import subprocess #Can't use pytorch to get the GPU names because the cuda malloc has to be set before the first import. diff --git a/custom_nodes/websocket_image_save.py b/custom_nodes/websocket_image_save.py index 09fe1bde5..d09ef0e27 100644 --- a/custom_nodes/websocket_image_save.py +++ b/custom_nodes/websocket_image_save.py @@ -2,7 +2,7 @@ from PIL import Image, ImageOps from io import BytesIO import numpy as np import struct -import comfy.utils +import seap.utils import time #You can use this node to save full size images through the websocket, the @@ -27,7 +27,7 @@ class SaveImageWebsocket: CATEGORY = "api/image" def save_images(self, images): - pbar = comfy.utils.ProgressBar(images.shape[0]) + pbar = seap.utils.ProgressBar(images.shape[0]) step = 0 for image in images: i = 255. * image.cpu().numpy() diff --git a/execution.py b/execution.py index 6c386341b..46f821e31 100644 --- a/execution.py +++ b/execution.py @@ -12,11 +12,11 @@ from typing import List, Literal, NamedTuple, Optional import torch 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, CacheKeySetInputSignature, CacheKeySetID -from comfy.cli_args import args +import seap.model_management +from seap_execution.graph import get_input_info, ExecutionList, DynamicPrompt, ExecutionBlocker +from seap_execution.graph_utils import is_link, GraphBuilder +from seap_execution.caching import HierarchicalCache, LRUCache, CacheKeySetInputSignature, CacheKeySetID +from seap.cli_args import args class ExecutionResult(Enum): SUCCESS = 0 @@ -371,7 +371,7 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, promp pending_subgraph_results[unique_id] = cached_outputs return (ExecutionResult.PENDING, None, None) caches.outputs.set(unique_id, output_data) - except comfy.model_management.InterruptProcessingException as iex: + except seap.model_management.InterruptProcessingException as iex: logging.info("Processing interrupted") # skip formatting inputs/outputs @@ -399,9 +399,9 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, promp "traceback": traceback.format_tb(tb), "current_inputs": input_data_formatted } - if isinstance(ex, comfy.model_management.OOM_EXCEPTION): + if isinstance(ex, seap.model_management.OOM_EXCEPTION): logging.error("Got an OOM, unloading all loaded models.") - comfy.model_management.unload_all_models() + seap.model_management.unload_all_models() return (ExecutionResult.FAILURE, error_details, ex) @@ -435,7 +435,7 @@ class PromptExecutor: # First, send back the status to the frontend depending # on the exception type - if isinstance(ex, comfy.model_management.InterruptProcessingException): + if isinstance(ex, seap.model_management.InterruptProcessingException): mes = { "prompt_id": prompt_id, "node_id": node_id, @@ -480,7 +480,7 @@ class PromptExecutor: if self.caches.outputs.get(node_id) is not None: cached_nodes.append(node_id) - comfy.model_management.cleanup_models(keep_clone_weights_loaded=True) + seap.model_management.cleanup_models(keep_clone_weights_loaded=True) self.add_message("execution_cached", { "nodes": cached_nodes, "prompt_id": prompt_id}, broadcast=False) @@ -523,8 +523,8 @@ class PromptExecutor: "meta": meta_outputs, } self.server.last_node_id = None - if comfy.model_management.DISABLE_SMART_MEMORY: - comfy.model_management.unload_all_models() + if seap.model_management.DISABLE_SMART_MEMORY: + seap.model_management.unload_all_models() diff --git a/latent_preview.py b/latent_preview.py index ae9211a27..161e1ad3e 100644 --- a/latent_preview.py +++ b/latent_preview.py @@ -2,11 +2,11 @@ import torch from PIL import Image import struct import numpy as np -from comfy.cli_args import args, LatentPreviewMethod -from comfy.taesd.taesd import TAESD -import comfy.model_management +from seap.cli_args import args, LatentPreviewMethod +from seap.taesd.taesd import TAESD +import seap.model_management import folder_paths -import comfy.utils +import seap.utils import logging MAX_PREVIEW_RESOLUTION = args.preview_size @@ -14,7 +14,7 @@ MAX_PREVIEW_RESOLUTION = args.preview_size def preview_to_image(latent_image): latents_ubyte = (((latent_image + 1.0) / 2.0).clamp(0, 1) # change scale from -1..1 to 0..1 .mul(0xFF) # to 0..255 - ).to(device="cpu", dtype=torch.uint8, non_blocking=comfy.model_management.device_supports_non_blocking(latent_image.device)) + ).to(device="cpu", dtype=torch.uint8, non_blocking=seap.model_management.device_supports_non_blocking(latent_image.device)) return Image.fromarray(latents_ubyte.numpy()) @@ -89,7 +89,7 @@ def prepare_callback(model, steps, x0_output_dict=None): previewer = get_previewer(model.load_device, model.model.latent_format) - pbar = comfy.utils.ProgressBar(steps) + pbar = seap.utils.ProgressBar(steps) def callback(step, x0, x, total_steps): if x0_output_dict is not None: x0_output_dict["x0"] = x0 diff --git a/main.py b/main.py index c23210861..2516fd3a3 100644 --- a/main.py +++ b/main.py @@ -1,11 +1,11 @@ -import comfy.options -comfy.options.enable_args_parsing() +import seap.options +seap.options.enable_args_parsing() import os import importlib.util import folder_paths import time -from comfy.cli_args import args +from seap.cli_args import args from app.logger import setup_logger @@ -85,17 +85,17 @@ if args.windows_standalone_build: except: pass -import comfy.utils +import seap.utils import execution import server from server import BinaryEventTypes import nodes -import comfy.model_management +import seap.model_management def cuda_malloc_warning(): - device = comfy.model_management.get_torch_device() - device_name = comfy.model_management.get_torch_device_name(device) + device = seap.model_management.get_torch_device() + device_name = seap.model_management.get_torch_device_name(device) cuda_malloc_warning = False if "cudaMallocAsync" in device_name: for b in cuda_malloc.blacklist: @@ -141,7 +141,7 @@ def prompt_worker(q, server): free_memory = flags.get("free_memory", False) if flags.get("unload_models", free_memory): - comfy.model_management.unload_all_models() + seap.model_management.unload_all_models() need_gc = True last_gc_collect = 0 @@ -153,9 +153,9 @@ def prompt_worker(q, server): if need_gc: current_time = time.perf_counter() if (current_time - last_gc_collect) > gc_collect_interval: - comfy.model_management.cleanup_models() + seap.model_management.cleanup_models() gc.collect() - comfy.model_management.soft_empty_cache() + seap.model_management.soft_empty_cache() last_gc_collect = current_time need_gc = False @@ -168,13 +168,13 @@ async def run(server, address='', port=8188, verbose=True, call_on_start=None): def hijack_progress(server): def hook(value, total, preview_image): - comfy.model_management.throw_exception_if_processing_interrupted() + seap.model_management.throw_exception_if_processing_interrupted() progress = {"value": value, "max": total, "prompt_id": server.last_prompt_id, "node": server.last_node_id} server.send_sync("progress", progress, server.client_id) if preview_image is not None: server.send_sync(BinaryEventTypes.UNENCODED_PREVIEW_IMAGE, preview_image, server.client_id) - comfy.utils.set_progress_bar_global_hook(hook) + seap.utils.set_progress_bar_global_hook(hook) def cleanup_temp(): diff --git a/node_helpers.py b/node_helpers.py index 4b38bfff8..f7d83a6fd 100644 --- a/node_helpers.py +++ b/node_helpers.py @@ -1,6 +1,6 @@ import hashlib -from comfy.cli_args import args +from seap.cli_args import args from PIL import ImageFile, UnidentifiedImageError diff --git a/nodes.py b/nodes.py index 15a783529..2a4351139 100644 --- a/nodes.py +++ b/nodes.py @@ -16,19 +16,19 @@ from PIL.PngImagePlugin import PngInfo import numpy as np import safetensors.torch -sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy")) +sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "seap")) -import comfy.diffusers_load -import comfy.samplers -import comfy.sample -import comfy.sd -import comfy.utils -import comfy.controlnet +import seap.diffusers_load +import seap.samplers +import seap.sample +import seap.sd +import seap.utils +import seap.controlnet -import comfy.clip_vision +import seap.clip_vision -import comfy.model_management -from comfy.cli_args import args +import seap.model_management +from seap.cli_args import args import importlib @@ -37,10 +37,10 @@ import latent_preview import node_helpers def before_node_execution(): - comfy.model_management.throw_exception_if_processing_interrupted() + seap.model_management.throw_exception_if_processing_interrupted() def interrupt_processing(value=True): - comfy.model_management.interrupt_current_processing(value) + seap.model_management.interrupt_current_processing(value) MAX_RESOLUTION=16384 @@ -462,7 +462,7 @@ class SaveLatent: output["latent_tensor"] = samples["samples"] output["latent_format_version_0"] = torch.tensor([]) - comfy.utils.save_torch_file(output, file, metadata=metadata) + seap.utils.save_torch_file(output, file, metadata=metadata) return { "ui": { "latents": results } } @@ -516,7 +516,7 @@ class CheckpointLoader: def load_checkpoint(self, config_name, ckpt_name): config_path = folder_paths.get_full_path("configs", config_name) ckpt_path = folder_paths.get_full_path_or_raise("checkpoints", ckpt_name) - return comfy.sd.load_checkpoint(config_path, ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) + return seap.sd.load_checkpoint(config_path, ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) class CheckpointLoaderSimple: @classmethod @@ -537,7 +537,7 @@ class CheckpointLoaderSimple: def load_checkpoint(self, ckpt_name): ckpt_path = folder_paths.get_full_path_or_raise("checkpoints", ckpt_name) - out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) + out = seap.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) return out[:3] class DiffusersLoader: @@ -564,7 +564,7 @@ class DiffusersLoader: model_path = path break - return comfy.diffusers_load.load_diffusers(model_path, output_vae=output_vae, output_clip=output_clip, embedding_directory=folder_paths.get_folder_paths("embeddings")) + return seap.diffusers_load.load_diffusers(model_path, output_vae=output_vae, output_clip=output_clip, embedding_directory=folder_paths.get_folder_paths("embeddings")) class unCLIPCheckpointLoader: @@ -579,7 +579,7 @@ class unCLIPCheckpointLoader: def load_checkpoint(self, ckpt_name, output_vae=True, output_clip=True): ckpt_path = folder_paths.get_full_path_or_raise("checkpoints", ckpt_name) - out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) + out = seap.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) return out class CLIPSetLastLayer: @@ -636,10 +636,10 @@ class LoraLoader: del temp if lora is None: - lora = comfy.utils.load_torch_file(lora_path, safe_load=True) + lora = seap.utils.load_torch_file(lora_path, safe_load=True) self.loaded_lora = (lora_path, lora) - model_lora, clip_lora = comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip) + model_lora, clip_lora = seap.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip) return (model_lora, clip_lora) class LoraLoaderModelOnly(LoraLoader): @@ -704,11 +704,11 @@ class VAELoader: encoder = next(filter(lambda a: a.startswith("{}_encoder.".format(name)), approx_vaes)) decoder = next(filter(lambda a: a.startswith("{}_decoder.".format(name)), approx_vaes)) - enc = comfy.utils.load_torch_file(folder_paths.get_full_path_or_raise("vae_approx", encoder)) + enc = seap.utils.load_torch_file(folder_paths.get_full_path_or_raise("vae_approx", encoder)) for k in enc: sd["taesd_encoder.{}".format(k)] = enc[k] - dec = comfy.utils.load_torch_file(folder_paths.get_full_path_or_raise("vae_approx", decoder)) + dec = seap.utils.load_torch_file(folder_paths.get_full_path_or_raise("vae_approx", decoder)) for k in dec: sd["taesd_decoder.{}".format(k)] = dec[k] @@ -740,8 +740,8 @@ class VAELoader: sd = self.load_taesd(vae_name) else: vae_path = folder_paths.get_full_path_or_raise("vae", vae_name) - sd = comfy.utils.load_torch_file(vae_path) - vae = comfy.sd.VAE(sd=sd) + sd = seap.utils.load_torch_file(vae_path) + vae = seap.sd.VAE(sd=sd) return (vae,) class ControlNetLoader: @@ -756,7 +756,7 @@ 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) + controlnet = seap.controlnet.load_controlnet(controlnet_path) return (controlnet,) class DiffControlNetLoader: @@ -772,7 +772,7 @@ class DiffControlNetLoader: def load_controlnet(self, model, control_net_name): controlnet_path = folder_paths.get_full_path_or_raise("controlnet", control_net_name) - controlnet = comfy.controlnet.load_controlnet(controlnet_path, model) + controlnet = seap.controlnet.load_controlnet(controlnet_path, model) return (controlnet,) @@ -879,7 +879,7 @@ class UNETLoader: model_options["dtype"] = torch.float8_e5m2 unet_path = folder_paths.get_full_path_or_raise("diffusion_models", unet_name) - model = comfy.sd.load_diffusion_model(unet_path, model_options=model_options) + model = seap.sd.load_diffusion_model(unet_path, model_options=model_options) return (model,) class CLIPLoader: @@ -895,16 +895,16 @@ class CLIPLoader: def load_clip(self, clip_name, type="stable_diffusion"): if type == "stable_cascade": - clip_type = comfy.sd.CLIPType.STABLE_CASCADE + clip_type = seap.sd.CLIPType.STABLE_CASCADE elif type == "sd3": - clip_type = comfy.sd.CLIPType.SD3 + clip_type = seap.sd.CLIPType.SD3 elif type == "stable_audio": - clip_type = comfy.sd.CLIPType.STABLE_AUDIO + clip_type = seap.sd.CLIPType.STABLE_AUDIO else: - clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION + clip_type = seap.sd.CLIPType.STABLE_DIFFUSION clip_path = folder_paths.get_full_path_or_raise("clip", clip_name) - clip = comfy.sd.load_clip(ckpt_paths=[clip_path], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type) + clip = seap.sd.load_clip(ckpt_paths=[clip_path], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type) return (clip,) class DualCLIPLoader: @@ -923,13 +923,13 @@ class DualCLIPLoader: clip_path1 = folder_paths.get_full_path_or_raise("clip", clip_name1) clip_path2 = folder_paths.get_full_path_or_raise("clip", clip_name2) if type == "sdxl": - clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION + clip_type = seap.sd.CLIPType.STABLE_DIFFUSION elif type == "sd3": - clip_type = comfy.sd.CLIPType.SD3 + clip_type = seap.sd.CLIPType.SD3 elif type == "flux": - clip_type = comfy.sd.CLIPType.FLUX + clip_type = seap.sd.CLIPType.FLUX - clip = comfy.sd.load_clip(ckpt_paths=[clip_path1, clip_path2], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type) + clip = seap.sd.load_clip(ckpt_paths=[clip_path1, clip_path2], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type) return (clip,) class CLIPVisionLoader: @@ -944,7 +944,7 @@ 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) + clip_vision = seap.clip_vision.load(clip_path) return (clip_vision,) class CLIPVisionEncode: @@ -974,7 +974,7 @@ class StyleModelLoader: def load_style_model(self, style_model_name): style_model_path = folder_paths.get_full_path_or_raise("style_models", style_model_name) - style_model = comfy.sd.load_style_model(style_model_path) + style_model = seap.sd.load_style_model(style_model_path) return (style_model,) @@ -1039,7 +1039,7 @@ class GLIGENLoader: def load_gligen(self, gligen_name): gligen_path = folder_paths.get_full_path_or_raise("gligen", gligen_name) - gligen = comfy.sd.load_gligen(gligen_path) + gligen = seap.sd.load_gligen(gligen_path) return (gligen,) class GLIGENTextBoxApply: @@ -1075,7 +1075,7 @@ class GLIGENTextBoxApply: class EmptyLatentImage: def __init__(self): - self.device = comfy.model_management.intermediate_device() + self.device = seap.model_management.intermediate_device() @classmethod def INPUT_TYPES(s): @@ -1187,7 +1187,7 @@ class LatentUpscale: width = max(64, width) height = max(64, height) - s["samples"] = comfy.utils.common_upscale(samples["samples"], width // 8, height // 8, upscale_method, crop) + s["samples"] = seap.utils.common_upscale(samples["samples"], width // 8, height // 8, upscale_method, crop) return (s,) class LatentUpscaleBy: @@ -1206,7 +1206,7 @@ class LatentUpscaleBy: s = samples.copy() width = round(samples["samples"].shape[3] * scale_by) height = round(samples["samples"].shape[2] * scale_by) - s["samples"] = comfy.utils.common_upscale(samples["samples"], width, height, upscale_method, "disabled") + s["samples"] = seap.utils.common_upscale(samples["samples"], width, height, upscale_method, "disabled") return (s,) class LatentRotate: @@ -1322,7 +1322,7 @@ class LatentBlend: if samples1.shape != samples2.shape: samples2.permute(0, 3, 1, 2) - samples2 = comfy.utils.common_upscale(samples2, samples1.shape[3], samples1.shape[2], 'bicubic', crop='center') + samples2 = seap.utils.common_upscale(samples2, samples1.shape[3], samples1.shape[2], 'bicubic', crop='center') samples2.permute(0, 2, 3, 1) samples_blended = self.blend_mode(samples1, samples2, blend_mode) @@ -1387,23 +1387,23 @@ class SetLatentNoiseMask: def common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent, denoise=1.0, disable_noise=False, start_step=None, last_step=None, force_full_denoise=False): latent_image = latent["samples"] - latent_image = comfy.sample.fix_empty_latent_channels(model, latent_image) + latent_image = seap.sample.fix_empty_latent_channels(model, latent_image) if disable_noise: noise = torch.zeros(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout, device="cpu") else: batch_inds = latent["batch_index"] if "batch_index" in latent else None - noise = comfy.sample.prepare_noise(latent_image, seed, batch_inds) + noise = seap.sample.prepare_noise(latent_image, seed, batch_inds) noise_mask = None if "noise_mask" in latent: noise_mask = latent["noise_mask"] callback = latent_preview.prepare_callback(model, steps) - disable_pbar = not comfy.utils.PROGRESS_BAR_ENABLED - samples = comfy.sample.sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, - denoise=denoise, disable_noise=disable_noise, start_step=start_step, last_step=last_step, - force_full_denoise=force_full_denoise, noise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed) + disable_pbar = not seap.utils.PROGRESS_BAR_ENABLED + samples = seap.sample.sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, + denoise=denoise, disable_noise=disable_noise, start_step=start_step, last_step=last_step, + force_full_denoise=force_full_denoise, noise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed) out = latent.copy() out["samples"] = samples return (out, ) @@ -1417,8 +1417,8 @@ class KSampler: "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "tooltip": "The random seed used for creating the noise."}), "steps": ("INT", {"default": 20, "min": 1, "max": 10000, "tooltip": "The number of steps used in the denoising process."}), "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01, "tooltip": "The Classifier-Free Guidance scale balances creativity and adherence to the prompt. Higher values result in images more closely matching the prompt however too high values will negatively impact quality."}), - "sampler_name": (comfy.samplers.KSampler.SAMPLERS, {"tooltip": "The algorithm used when sampling, this can affect the quality, speed, and style of the generated output."}), - "scheduler": (comfy.samplers.KSampler.SCHEDULERS, {"tooltip": "The scheduler controls how noise is gradually removed to form the image."}), + "sampler_name": (seap.samplers.KSampler.SAMPLERS, {"tooltip": "The algorithm used when sampling, this can affect the quality, speed, and style of the generated output."}), + "scheduler": (seap.samplers.KSampler.SCHEDULERS, {"tooltip": "The scheduler controls how noise is gradually removed to form the image."}), "positive": ("CONDITIONING", {"tooltip": "The conditioning describing the attributes you want to include in the image."}), "negative": ("CONDITIONING", {"tooltip": "The conditioning describing the attributes you want to exclude from the image."}), "latent_image": ("LATENT", {"tooltip": "The latent image to denoise."}), @@ -1445,8 +1445,8 @@ class KSamplerAdvanced: "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), "steps": ("INT", {"default": 20, "min": 1, "max": 10000}), "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01}), - "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ), - "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ), + "sampler_name": (seap.samplers.KSampler.SAMPLERS,), + "scheduler": (seap.samplers.KSampler.SCHEDULERS,), "positive": ("CONDITIONING", ), "negative": ("CONDITIONING", ), "latent_image": ("LATENT", ), @@ -1686,7 +1686,7 @@ class ImageScale: elif height == 0: height = max(1, round(samples.shape[2] * width / samples.shape[3])) - s = comfy.utils.common_upscale(samples, width, height, upscale_method, crop) + s = seap.utils.common_upscale(samples, width, height, upscale_method, crop) s = s.movedim(1,-1) return (s,) @@ -1706,7 +1706,7 @@ class ImageScaleBy: samples = image.movedim(-1,1) width = round(samples.shape[3] * scale_by) height = round(samples.shape[2] * scale_by) - s = comfy.utils.common_upscale(samples, width, height, upscale_method, "disabled") + s = seap.utils.common_upscale(samples, width, height, upscale_method, "disabled") s = s.movedim(1,-1) return (s,) @@ -1738,7 +1738,7 @@ class ImageBatch: def batch(self, image1, image2): if image1.shape[1:] != image2.shape[1:]: - image2 = comfy.utils.common_upscale(image2.movedim(-1,1), image1.shape[2], image1.shape[1], "bilinear", "center").movedim(1,-1) + image2 = seap.utils.common_upscale(image2.movedim(-1, 1), image1.shape[2], image1.shape[1], "bilinear", "center").movedim(1, -1) s = torch.cat((image1, image2), dim=0) return (s,) @@ -2061,13 +2061,13 @@ def init_builtin_extra_nodes(): """ Initializes the built-in extra nodes in ComfyUI. - This function loads the extra node files located in the "comfy_extras" directory and imports them into ComfyUI. + This function loads the extra node files located in the "seap_extras" directory and imports them into ComfyUI. If any of the extra node files fail to import, a warning message is logged. Returns: None """ - extras_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras") + extras_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "seap_extras") extras_files = [ "nodes_latent.py", "nodes_hypernetwork.py", @@ -2115,7 +2115,7 @@ def init_builtin_extra_nodes(): import_failed = [] for node_file in extras_files: - if not load_custom_node(os.path.join(extras_dir, node_file), module_parent="comfy_extras"): + if not load_custom_node(os.path.join(extras_dir, node_file), module_parent="seap_extras"): import_failed.append(node_file) return import_failed @@ -2130,7 +2130,7 @@ def init_extra_nodes(init_custom_nodes=True): logging.info("Skipping loading of custom nodes") if len(import_failed) > 0: - logging.warning("WARNING: some comfy_extras/ nodes did not import correctly. This may be because they are missing some dependencies.\n") + logging.warning("WARNING: some seap_extras/ nodes did not import correctly. This may be because they are missing some dependencies.\n") for node in import_failed: logging.warning("IMPORT FAILED: {}".format(node)) logging.warning("\nThis issue might be caused by new missing dependencies added the last time you updated ComfyUI.") diff --git a/comfy/checkpoint_pickle.py b/seap/checkpoint_pickle.py similarity index 100% rename from comfy/checkpoint_pickle.py rename to seap/checkpoint_pickle.py diff --git a/comfy/cldm/cldm.py b/seap/cldm/cldm.py similarity index 99% rename from comfy/cldm/cldm.py rename to seap/cldm/cldm.py index 9ec64a227..47e6f672c 100644 --- a/comfy/cldm/cldm.py +++ b/seap/cldm/cldm.py @@ -15,8 +15,8 @@ from ..ldm.modules.diffusionmodules.openaimodel import UNetModel, TimestepEmbedS from ..ldm.util import exists from .control_types import UNION_CONTROLNET_TYPES from collections import OrderedDict -import comfy.ops -from comfy.ldm.modules.attention import optimized_attention +import seap.ops +from seap.ldm.modules.attention import optimized_attention class OptimizedAttention(nn.Module): def __init__(self, c, nhead, dropout=0.0, dtype=None, device=None, operations=None): @@ -95,7 +95,7 @@ class ControlNet(nn.Module): attn_precision=None, union_controlnet_num_control_type=None, device=None, - operations=comfy.ops.disable_weight_init, + operations=seap.ops.disable_weight_init, **kwargs, ): super().__init__() diff --git a/comfy/cldm/control_types.py b/seap/cldm/control_types.py similarity index 100% rename from comfy/cldm/control_types.py rename to seap/cldm/control_types.py diff --git a/comfy/cldm/mmdit.py b/seap/cldm/mmdit.py similarity index 92% rename from comfy/cldm/mmdit.py rename to seap/cldm/mmdit.py index 54a58ab83..12d475822 100644 --- a/comfy/cldm/mmdit.py +++ b/seap/cldm/mmdit.py @@ -1,8 +1,8 @@ import torch from typing import Dict, Optional -import comfy.ldm.modules.diffusionmodules.mmdit +import seap.ldm.modules.diffusionmodules.mmdit -class ControlNet(comfy.ldm.modules.diffusionmodules.mmdit.MMDiT): +class ControlNet(seap.ldm.modules.diffusionmodules.mmdit.MMDiT): def __init__( self, num_blocks = None, @@ -21,7 +21,7 @@ class ControlNet(comfy.ldm.modules.diffusionmodules.mmdit.MMDiT): if control_latent_channels is None: control_latent_channels = self.in_channels - self.pos_embed_input = comfy.ldm.modules.diffusionmodules.mmdit.PatchEmbed( + self.pos_embed_input = seap.ldm.modules.diffusionmodules.mmdit.PatchEmbed( None, self.patch_size, control_latent_channels, diff --git a/comfy/cli_args.py b/seap/cli_args.py similarity index 99% rename from comfy/cli_args.py rename to seap/cli_args.py index 20b9f4749..4ed6a594d 100644 --- a/comfy/cli_args.py +++ b/seap/cli_args.py @@ -2,7 +2,7 @@ import argparse import enum import os from typing import Optional -import comfy.options +import seap.options class EnumAction(argparse.Action): @@ -173,7 +173,7 @@ parser.add_argument( parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path.") -if comfy.options.args_parsing: +if seap.options.args_parsing: args = parser.parse_args() else: args = parser.parse_args([]) diff --git a/comfy/clip_config_bigg.json b/seap/clip_config_bigg.json similarity index 100% rename from comfy/clip_config_bigg.json rename to seap/clip_config_bigg.json diff --git a/comfy/clip_model.py b/seap/clip_model.py similarity index 95% rename from comfy/clip_model.py rename to seap/clip_model.py index 42cdc4f6e..588e2fef4 100644 --- a/comfy/clip_model.py +++ b/seap/clip_model.py @@ -1,6 +1,6 @@ import torch -from comfy.ldm.modules.attention import optimized_attention_for_device -import comfy.ops +from seap.ldm.modules.attention import optimized_attention_for_device +import seap.ops class CLIPAttention(torch.nn.Module): def __init__(self, embed_dim, heads, dtype, device, operations): @@ -78,7 +78,7 @@ class CLIPEmbeddings(torch.nn.Module): self.position_embedding = operations.Embedding(num_positions, embed_dim, dtype=dtype, device=device) def forward(self, input_tokens, dtype=torch.float32): - return self.token_embedding(input_tokens, out_dtype=dtype) + comfy.ops.cast_to(self.position_embedding.weight, dtype=dtype, device=input_tokens.device) + return self.token_embedding(input_tokens, out_dtype=dtype) + seap.ops.cast_to(self.position_embedding.weight, dtype=dtype, device=input_tokens.device) class CLIPTextModel_(torch.nn.Module): @@ -159,7 +159,7 @@ class CLIPVisionEmbeddings(torch.nn.Module): def forward(self, pixel_values): embeds = self.patch_embedding(pixel_values).flatten(2).transpose(1, 2) - return torch.cat([comfy.ops.cast_to_input(self.class_embedding, embeds).expand(pixel_values.shape[0], 1, -1), embeds], dim=1) + comfy.ops.cast_to_input(self.position_embedding.weight, embeds) + return torch.cat([seap.ops.cast_to_input(self.class_embedding, embeds).expand(pixel_values.shape[0], 1, -1), embeds], dim=1) + seap.ops.cast_to_input(self.position_embedding.weight, embeds) class CLIPVision(torch.nn.Module): diff --git a/comfy/clip_vision.py b/seap/clip_vision.py similarity index 82% rename from comfy/clip_vision.py rename to seap/clip_vision.py index 64392e270..9fc3f4b03 100644 --- a/comfy/clip_vision.py +++ b/seap/clip_vision.py @@ -4,11 +4,11 @@ import torch import json import logging -import comfy.ops -import comfy.model_patcher -import comfy.model_management -import comfy.utils -import comfy.clip_model +import seap.ops +import seap.model_patcher +import seap.model_management +import seap.utils +import seap.clip_model class Output: def __getitem__(self, key): @@ -35,13 +35,13 @@ class ClipVisionModel(): config = json.load(f) self.image_size = config.get("image_size", 224) - self.load_device = comfy.model_management.text_encoder_device() - offload_device = comfy.model_management.text_encoder_offload_device() - self.dtype = comfy.model_management.text_encoder_dtype(self.load_device) - self.model = comfy.clip_model.CLIPVisionModelProjection(config, self.dtype, offload_device, comfy.ops.manual_cast) + self.load_device = seap.model_management.text_encoder_device() + offload_device = seap.model_management.text_encoder_offload_device() + self.dtype = seap.model_management.text_encoder_dtype(self.load_device) + self.model = seap.clip_model.CLIPVisionModelProjection(config, self.dtype, offload_device, seap.ops.manual_cast) self.model.eval() - self.patcher = comfy.model_patcher.ModelPatcher(self.model, load_device=self.load_device, offload_device=offload_device) + self.patcher = seap.model_patcher.ModelPatcher(self.model, load_device=self.load_device, offload_device=offload_device) def load_sd(self, sd): return self.model.load_state_dict(sd, strict=False) @@ -50,14 +50,14 @@ class ClipVisionModel(): return self.model.state_dict() def encode_image(self, image): - comfy.model_management.load_model_gpu(self.patcher) + seap.model_management.load_model_gpu(self.patcher) pixel_values = clip_preprocess(image.to(self.load_device), size=self.image_size).float() out = self.model(pixel_values=pixel_values, intermediate_output=-2) outputs = Output() - outputs["last_hidden_state"] = out[0].to(comfy.model_management.intermediate_device()) - outputs["image_embeds"] = out[2].to(comfy.model_management.intermediate_device()) - outputs["penultimate_hidden_states"] = out[1].to(comfy.model_management.intermediate_device()) + outputs["last_hidden_state"] = out[0].to(seap.model_management.intermediate_device()) + outputs["image_embeds"] = out[2].to(seap.model_management.intermediate_device()) + outputs["penultimate_hidden_states"] = out[1].to(seap.model_management.intermediate_device()) return outputs def convert_to_transformers(sd, prefix): diff --git a/comfy/clip_vision_config_g.json b/seap/clip_vision_config_g.json similarity index 100% rename from comfy/clip_vision_config_g.json rename to seap/clip_vision_config_g.json diff --git a/comfy/clip_vision_config_h.json b/seap/clip_vision_config_h.json similarity index 100% rename from comfy/clip_vision_config_h.json rename to seap/clip_vision_config_h.json diff --git a/comfy/clip_vision_config_vitl.json b/seap/clip_vision_config_vitl.json similarity index 100% rename from comfy/clip_vision_config_vitl.json rename to seap/clip_vision_config_vitl.json diff --git a/comfy/clip_vision_config_vitl_336.json b/seap/clip_vision_config_vitl_336.json similarity index 100% rename from comfy/clip_vision_config_vitl_336.json rename to seap/clip_vision_config_vitl_336.json diff --git a/comfy/comfy_types.py b/seap/comfy_types.py similarity index 91% rename from comfy/comfy_types.py rename to seap/comfy_types.py index 70cf4b158..ad24d6c3d 100644 --- a/comfy/comfy_types.py +++ b/seap/comfy_types.py @@ -3,7 +3,7 @@ from typing import Callable, Protocol, TypedDict, Optional, List class UnetApplyFunction(Protocol): - """Function signature protocol on comfy.model_base.BaseModel.apply_model""" + """Function signature protocol on seap.model_base.BaseModel.apply_model""" def __call__(self, x: torch.Tensor, t: torch.Tensor, **kwargs) -> torch.Tensor: pass diff --git a/comfy/conds.py b/seap/conds.py similarity index 91% rename from comfy/conds.py rename to seap/conds.py index 660690af8..640ee3e96 100644 --- a/comfy/conds.py +++ b/seap/conds.py @@ -1,6 +1,6 @@ import torch import math -import comfy.utils +import seap.utils def lcm(a, b): #TODO: eventually replace by math.lcm (added in python3.9) @@ -14,7 +14,7 @@ class CONDRegular: return self.__class__(cond) def process_cond(self, batch_size, device, **kwargs): - return self._copy_with(comfy.utils.repeat_to_batch_size(self.cond, batch_size).to(device)) + return self._copy_with(seap.utils.repeat_to_batch_size(self.cond, batch_size).to(device)) def can_concat(self, other): if self.cond.shape != other.cond.shape: @@ -35,7 +35,7 @@ class CONDNoiseShape(CONDRegular): for i in range(dims): data = data.narrow(i + 2, area[i + dims], area[i]) - return self._copy_with(comfy.utils.repeat_to_batch_size(data, batch_size).to(device)) + return self._copy_with(seap.utils.repeat_to_batch_size(data, batch_size).to(device)) class CONDCrossAttn(CONDRegular): diff --git a/comfy/controlnet.py b/seap/controlnet.py similarity index 83% rename from comfy/controlnet.py rename to seap/controlnet.py index 1d24afa6f..cbd33d794 100644 --- a/comfy/controlnet.py +++ b/seap/controlnet.py @@ -22,19 +22,19 @@ from enum import Enum import math import os import logging -import comfy.utils -import comfy.model_management -import comfy.model_detection -import comfy.model_patcher -import comfy.ops -import comfy.latent_formats +import seap.utils +import seap.model_management +import seap.model_detection +import seap.model_patcher +import seap.ops +import seap.latent_formats -import comfy.cldm.cldm -import comfy.t2i_adapter.adapter -import comfy.ldm.cascade.controlnet -import comfy.cldm.mmdit -import comfy.ldm.hydit.controlnet -import comfy.ldm.flux.controlnet +import seap.cldm.cldm +import seap.t2i_adapter.adapter +import seap.ldm.cascade.controlnet +import seap.cldm.mmdit +import seap.ldm.hydit.controlnet +import seap.ldm.flux.controlnet def broadcast_image_to(tensor, target_batch_size, batched_number): @@ -74,7 +74,7 @@ class ControlBase: self.extra_args = {} if device is None: - device = comfy.model_management.get_torch_device() + device = seap.model_management.get_torch_device() self.device = device self.previous_controlnet = None self.extra_conds = [] @@ -190,7 +190,7 @@ class ControlNet(ControlBase): self.control_model = control_model self.load_device = load_device if control_model is not None: - self.control_model_wrapped = comfy.model_patcher.ModelPatcher(self.control_model, load_device=load_device, offload_device=comfy.model_management.unet_offload_device()) + self.control_model_wrapped = seap.model_patcher.ModelPatcher(self.control_model, load_device=load_device, offload_device=seap.model_management.unet_offload_device()) self.compression_ratio = compression_ratio self.global_average_pooling = global_average_pooling @@ -227,19 +227,19 @@ class ControlNet(ControlBase): else: if self.latent_format is not None: raise ValueError("This Controlnet needs a VAE but none was provided, please use a ControlNetApply node with a VAE input and connect it.") - self.cond_hint = comfy.utils.common_upscale(self.cond_hint_original, x_noisy.shape[3] * compression_ratio, x_noisy.shape[2] * compression_ratio, self.upscale_algorithm, "center") + self.cond_hint = seap.utils.common_upscale(self.cond_hint_original, x_noisy.shape[3] * compression_ratio, x_noisy.shape[2] * compression_ratio, self.upscale_algorithm, "center") if self.vae is not None: - loaded_models = comfy.model_management.loaded_models(only_currently_used=True) + loaded_models = seap.model_management.loaded_models(only_currently_used=True) self.cond_hint = self.vae.encode(self.cond_hint.movedim(1, -1)) - comfy.model_management.load_models_gpu(loaded_models) + seap.model_management.load_models_gpu(loaded_models) if self.latent_format is not None: self.cond_hint = self.latent_format.process_in(self.cond_hint) if len(self.extra_concat_orig) > 0: to_concat = [] for c in self.extra_concat_orig: c = c.to(self.cond_hint.device) - c = comfy.utils.common_upscale(c, self.cond_hint.shape[3], self.cond_hint.shape[2], self.upscale_algorithm, "center") - to_concat.append(comfy.utils.repeat_to_batch_size(c, self.cond_hint.shape[0])) + c = seap.utils.common_upscale(c, self.cond_hint.shape[3], self.cond_hint.shape[2], self.upscale_algorithm, "center") + to_concat.append(seap.utils.repeat_to_batch_size(c, self.cond_hint.shape[0])) self.cond_hint = torch.cat([self.cond_hint] + to_concat, dim=1) self.cond_hint = self.cond_hint.to(device=self.device, dtype=dtype) @@ -280,7 +280,7 @@ class ControlNet(ControlBase): super().cleanup() class ControlLoraOps: - class Linear(torch.nn.Module, comfy.ops.CastWeightBiasOp): + class Linear(torch.nn.Module, seap.ops.CastWeightBiasOp): def __init__(self, in_features: int, out_features: int, bias: bool = True, device=None, dtype=None) -> None: factory_kwargs = {'device': device, 'dtype': dtype} @@ -293,13 +293,13 @@ class ControlLoraOps: self.bias = None def forward(self, input): - weight, bias = comfy.ops.cast_bias_weight(self, input) + weight, bias = seap.ops.cast_bias_weight(self, input) if self.up is not None: return torch.nn.functional.linear(input, weight + (torch.mm(self.up.flatten(start_dim=1), self.down.flatten(start_dim=1))).reshape(self.weight.shape).type(input.dtype), bias) else: return torch.nn.functional.linear(input, weight, bias) - class Conv2d(torch.nn.Module, comfy.ops.CastWeightBiasOp): + class Conv2d(torch.nn.Module, seap.ops.CastWeightBiasOp): def __init__( self, in_channels, @@ -333,7 +333,7 @@ class ControlLoraOps: def forward(self, input): - weight, bias = comfy.ops.cast_bias_weight(self, input) + weight, bias = seap.ops.cast_bias_weight(self, input) if self.up is not None: return torch.nn.functional.conv2d(input, weight + (torch.mm(self.up.flatten(start_dim=1), self.down.flatten(start_dim=1))).reshape(self.weight.shape).type(input.dtype), bias, self.stride, self.padding, self.dilation, self.groups) else: @@ -355,17 +355,17 @@ class ControlLora(ControlNet): self.manual_cast_dtype = model.manual_cast_dtype dtype = model.get_dtype() if self.manual_cast_dtype is None: - class control_lora_ops(ControlLoraOps, comfy.ops.disable_weight_init): + class control_lora_ops(ControlLoraOps, seap.ops.disable_weight_init): pass else: - class control_lora_ops(ControlLoraOps, comfy.ops.manual_cast): + class control_lora_ops(ControlLoraOps, seap.ops.manual_cast): pass dtype = self.manual_cast_dtype controlnet_config["operations"] = control_lora_ops controlnet_config["dtype"] = dtype - self.control_model = comfy.cldm.cldm.ControlNet(**controlnet_config) - self.control_model.to(comfy.model_management.get_torch_device()) + self.control_model = seap.cldm.cldm.ControlNet(**controlnet_config) + self.control_model.to(seap.model_management.get_torch_device()) diffusion_model = model.diffusion_model sd = diffusion_model.state_dict() cm = self.control_model.state_dict() @@ -373,13 +373,13 @@ class ControlLora(ControlNet): for k in sd: weight = sd[k] try: - comfy.utils.set_attr_param(self.control_model, k, weight) + seap.utils.set_attr_param(self.control_model, k, weight) except: pass for k in self.control_weights: if k not in {"lora_controlnet"}: - comfy.utils.set_attr_param(self.control_model, k, self.control_weights[k].to(dtype).to(comfy.model_management.get_torch_device())) + seap.utils.set_attr_param(self.control_model, k, self.control_weights[k].to(dtype).to(seap.model_management.get_torch_device())) def copy(self): c = ControlLora(self.control_weights, global_average_pooling=self.global_average_pooling) @@ -396,29 +396,29 @@ class ControlLora(ControlNet): return out def inference_memory_requirements(self, dtype): - return comfy.utils.calculate_parameters(self.control_weights) * comfy.model_management.dtype_size(dtype) + ControlBase.inference_memory_requirements(self, dtype) + return seap.utils.calculate_parameters(self.control_weights) * seap.model_management.dtype_size(dtype) + ControlBase.inference_memory_requirements(self, dtype) def controlnet_config(sd, model_options={}): - model_config = comfy.model_detection.model_config_from_unet(sd, "", True) + model_config = seap.model_detection.model_config_from_unet(sd, "", True) unet_dtype = model_options.get("dtype", None) if unet_dtype is None: - weight_dtype = comfy.utils.weight_dtype(sd) + weight_dtype = seap.utils.weight_dtype(sd) supported_inference_dtypes = list(model_config.supported_inference_dtypes) if weight_dtype is not None: supported_inference_dtypes.append(weight_dtype) - unet_dtype = comfy.model_management.unet_dtype(model_params=-1, supported_dtypes=supported_inference_dtypes) + unet_dtype = seap.model_management.unet_dtype(model_params=-1, supported_dtypes=supported_inference_dtypes) - load_device = comfy.model_management.get_torch_device() - manual_cast_dtype = comfy.model_management.unet_manual_cast(unet_dtype, load_device) + load_device = seap.model_management.get_torch_device() + manual_cast_dtype = seap.model_management.unet_manual_cast(unet_dtype, load_device) operations = model_options.get("custom_operations", None) if operations is None: - operations = comfy.ops.pick_operations(unet_dtype, manual_cast_dtype, disable_fast_fp8=True) + operations = seap.ops.pick_operations(unet_dtype, manual_cast_dtype, disable_fast_fp8=True) - offload_device = comfy.model_management.unet_offload_device() + offload_device = seap.model_management.unet_offload_device() return model_config, operations, load_device, unet_dtype, manual_cast_dtype, offload_device def controlnet_load_state_dict(control_model, sd): @@ -432,9 +432,9 @@ def controlnet_load_state_dict(control_model, sd): return control_model def load_controlnet_mmdit(sd, model_options={}): - new_sd = comfy.model_detection.convert_diffusers_mmdit(sd, "") + new_sd = seap.model_detection.convert_diffusers_mmdit(sd, "") model_config, operations, load_device, unet_dtype, manual_cast_dtype, offload_device = controlnet_config(new_sd, model_options=model_options) - num_blocks = comfy.model_detection.count_blocks(new_sd, 'joint_blocks.{}.') + num_blocks = seap.model_detection.count_blocks(new_sd, 'joint_blocks.{}.') for k in sd: new_sd[k] = sd[k] @@ -443,10 +443,10 @@ def load_controlnet_mmdit(sd, model_options={}): if control_latent_channels == 17: #inpaint controlnet concat_mask = True - control_model = comfy.cldm.mmdit.ControlNet(num_blocks=num_blocks, control_latent_channels=control_latent_channels, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) + control_model = seap.cldm.mmdit.ControlNet(num_blocks=num_blocks, control_latent_channels=control_latent_channels, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) control_model = controlnet_load_state_dict(control_model, new_sd) - latent_format = comfy.latent_formats.SD3() + latent_format = seap.latent_formats.SD3() latent_format.shift_factor = 0 #SD3 controlnet weirdness control = ControlNet(control_model, compression_ratio=1, latent_format=latent_format, concat_mask=concat_mask, load_device=load_device, manual_cast_dtype=manual_cast_dtype) return control @@ -455,24 +455,24 @@ def load_controlnet_mmdit(sd, model_options={}): def load_controlnet_hunyuandit(controlnet_data, model_options={}): model_config, operations, load_device, unet_dtype, manual_cast_dtype, offload_device = controlnet_config(controlnet_data, model_options=model_options) - control_model = comfy.ldm.hydit.controlnet.HunYuanControlNet(operations=operations, device=offload_device, dtype=unet_dtype) + control_model = seap.ldm.hydit.controlnet.HunYuanControlNet(operations=operations, device=offload_device, dtype=unet_dtype) control_model = controlnet_load_state_dict(control_model, controlnet_data) - latent_format = comfy.latent_formats.SDXL() + latent_format = seap.latent_formats.SDXL() extra_conds = ['text_embedding_mask', 'encoder_hidden_states_t5', 'text_embedding_mask_t5', 'image_meta_size', 'style', 'cos_cis_img', 'sin_cis_img'] control = ControlNet(control_model, compression_ratio=1, latent_format=latent_format, load_device=load_device, manual_cast_dtype=manual_cast_dtype, extra_conds=extra_conds, strength_type=StrengthType.CONSTANT) return control def load_controlnet_flux_xlabs_mistoline(sd, mistoline=False, model_options={}): model_config, operations, load_device, unet_dtype, manual_cast_dtype, offload_device = controlnet_config(sd, model_options=model_options) - control_model = comfy.ldm.flux.controlnet.ControlNetFlux(mistoline=mistoline, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) + control_model = seap.ldm.flux.controlnet.ControlNetFlux(mistoline=mistoline, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) control_model = controlnet_load_state_dict(control_model, sd) extra_conds = ['y', 'guidance'] control = ControlNet(control_model, load_device=load_device, manual_cast_dtype=manual_cast_dtype, extra_conds=extra_conds) return control def load_controlnet_flux_instantx(sd, model_options={}): - new_sd = comfy.model_detection.convert_diffusers_mmdit(sd, "") + new_sd = seap.model_detection.convert_diffusers_mmdit(sd, "") model_config, operations, load_device, unet_dtype, manual_cast_dtype, offload_device = controlnet_config(new_sd, model_options=model_options) for k in sd: new_sd[k] = sd[k] @@ -487,16 +487,16 @@ def load_controlnet_flux_instantx(sd, model_options={}): if control_latent_channels == 17: concat_mask = True - control_model = comfy.ldm.flux.controlnet.ControlNetFlux(latent_input=True, num_union_modes=num_union_modes, control_latent_channels=control_latent_channels, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) + control_model = seap.ldm.flux.controlnet.ControlNetFlux(latent_input=True, num_union_modes=num_union_modes, control_latent_channels=control_latent_channels, operations=operations, device=offload_device, dtype=unet_dtype, **model_config.unet_config) control_model = controlnet_load_state_dict(control_model, new_sd) - latent_format = comfy.latent_formats.Flux() + latent_format = seap.latent_formats.Flux() extra_conds = ['y', 'guidance'] control = ControlNet(control_model, compression_ratio=1, latent_format=latent_format, concat_mask=concat_mask, load_device=load_device, manual_cast_dtype=manual_cast_dtype, extra_conds=extra_conds) return control def convert_mistoline(sd): - return comfy.utils.state_dict_prefix_replace(sd, {"single_controlnet_blocks.": "controlnet_single_blocks."}) + return seap.utils.state_dict_prefix_replace(sd, {"single_controlnet_blocks.": "controlnet_single_blocks."}) def load_controlnet_state_dict(state_dict, model=None, model_options={}): @@ -511,8 +511,8 @@ def load_controlnet_state_dict(state_dict, model=None, model_options={}): supported_inference_dtypes = None if "controlnet_cond_embedding.conv_in.weight" in controlnet_data: #diffusers format - controlnet_config = comfy.model_detection.unet_config_from_diffusers_unet(controlnet_data) - diffusers_keys = comfy.utils.unet_to_diffusers(controlnet_config) + controlnet_config = seap.model_detection.unet_config_from_diffusers_unet(controlnet_data) + diffusers_keys = seap.utils.unet_to_diffusers(controlnet_config) diffusers_keys["controlnet_mid_block.weight"] = "middle_block_out.0.weight" diffusers_keys["controlnet_mid_block.bias"] = "middle_block_out.0.bias" @@ -586,40 +586,40 @@ def load_controlnet_state_dict(state_dict, model=None, model_options={}): return net if controlnet_config is None: - model_config = comfy.model_detection.model_config_from_unet(controlnet_data, prefix, True) + model_config = seap.model_detection.model_config_from_unet(controlnet_data, prefix, True) supported_inference_dtypes = list(model_config.supported_inference_dtypes) controlnet_config = model_config.unet_config unet_dtype = model_options.get("dtype", None) if unet_dtype is None: - weight_dtype = comfy.utils.weight_dtype(controlnet_data) + weight_dtype = seap.utils.weight_dtype(controlnet_data) if supported_inference_dtypes is None: - supported_inference_dtypes = [comfy.model_management.unet_dtype()] + supported_inference_dtypes = [seap.model_management.unet_dtype()] if weight_dtype is not None: supported_inference_dtypes.append(weight_dtype) - unet_dtype = comfy.model_management.unet_dtype(model_params=-1, supported_dtypes=supported_inference_dtypes) + unet_dtype = seap.model_management.unet_dtype(model_params=-1, supported_dtypes=supported_inference_dtypes) - load_device = comfy.model_management.get_torch_device() + load_device = seap.model_management.get_torch_device() - manual_cast_dtype = comfy.model_management.unet_manual_cast(unet_dtype, load_device) + manual_cast_dtype = seap.model_management.unet_manual_cast(unet_dtype, load_device) operations = model_options.get("custom_operations", None) if operations is None: - operations = comfy.ops.pick_operations(unet_dtype, manual_cast_dtype) + operations = seap.ops.pick_operations(unet_dtype, manual_cast_dtype) controlnet_config["operations"] = operations controlnet_config["dtype"] = unet_dtype - controlnet_config["device"] = comfy.model_management.unet_offload_device() + controlnet_config["device"] = seap.model_management.unet_offload_device() controlnet_config.pop("out_channels") controlnet_config["hint_channels"] = controlnet_data["{}input_hint_block.0.weight".format(prefix)].shape[1] - control_model = comfy.cldm.cldm.ControlNet(**controlnet_config) + control_model = seap.cldm.cldm.ControlNet(**controlnet_config) if pth: if 'difference' in controlnet_data: if model is not None: - comfy.model_management.load_models_gpu([model]) + seap.model_management.load_models_gpu([model]) model_sd = model.model_state_dict() for x in controlnet_data: c_m = "control_model." @@ -655,7 +655,7 @@ def load_controlnet(ckpt_path, model=None, model_options={}): if filename.endswith("_shuffle") or filename.endswith("_shuffle_fp16"): #TODO: smarter way of enabling global_average_pooling model_options["global_average_pooling"] = True - cnet = load_controlnet_state_dict(comfy.utils.load_torch_file(ckpt_path, safe_load=True), model=model, model_options=model_options) + cnet = load_controlnet_state_dict(seap.utils.load_torch_file(ckpt_path, safe_load=True), model=model, model_options=model_options) if cnet is None: logging.error("error checkpoint does not contain controlnet or t2i adapter data {}".format(ckpt_path)) return cnet @@ -693,7 +693,7 @@ class T2IAdapter(ControlBase): self.control_input = None self.cond_hint = None width, height = self.scale_image_to(x_noisy.shape[3] * self.compression_ratio, x_noisy.shape[2] * self.compression_ratio) - self.cond_hint = comfy.utils.common_upscale(self.cond_hint_original, width, height, self.upscale_algorithm, "center").float().to(self.device) + self.cond_hint = seap.utils.common_upscale(self.cond_hint_original, width, height, self.upscale_algorithm, "center").float().to(self.device) if self.channels_in == 1 and self.cond_hint.shape[1] > 1: self.cond_hint = torch.mean(self.cond_hint, 1, keepdim=True) if x_noisy.shape[0] != self.cond_hint.shape[0]: @@ -728,12 +728,12 @@ def load_t2i_adapter(t2i_data, model_options={}): #TODO: model_options prefix_replace["adapter.body.{}.resnets.{}.".format(i, j)] = "body.{}.".format(i * 2 + j) prefix_replace["adapter.body.{}.".format(i, j)] = "body.{}.".format(i * 2) prefix_replace["adapter."] = "" - t2i_data = comfy.utils.state_dict_prefix_replace(t2i_data, prefix_replace) + t2i_data = seap.utils.state_dict_prefix_replace(t2i_data, prefix_replace) keys = t2i_data.keys() if "body.0.in_conv.weight" in keys: cin = t2i_data['body.0.in_conv.weight'].shape[1] - model_ad = comfy.t2i_adapter.adapter.Adapter_light(cin=cin, channels=[320, 640, 1280, 1280], nums_rb=4) + model_ad = seap.t2i_adapter.adapter.Adapter_light(cin=cin, channels=[320, 640, 1280, 1280], nums_rb=4) elif 'conv_in.weight' in keys: cin = t2i_data['conv_in.weight'].shape[1] channel = t2i_data['conv_in.weight'].shape[0] @@ -745,13 +745,13 @@ def load_t2i_adapter(t2i_data, model_options={}): #TODO: model_options xl = False if cin == 256 or cin == 768: xl = True - model_ad = comfy.t2i_adapter.adapter.Adapter(cin=cin, channels=[channel, channel*2, channel*4, channel*4][:4], nums_rb=2, ksize=ksize, sk=True, use_conv=use_conv, xl=xl) + model_ad = seap.t2i_adapter.adapter.Adapter(cin=cin, channels=[channel, channel * 2, channel * 4, channel * 4][:4], nums_rb=2, ksize=ksize, sk=True, use_conv=use_conv, xl=xl) elif "backbone.0.0.weight" in keys: - model_ad = comfy.ldm.cascade.controlnet.ControlNet(c_in=t2i_data['backbone.0.0.weight'].shape[1], proj_blocks=[0, 4, 8, 12, 51, 55, 59, 63]) + model_ad = seap.ldm.cascade.controlnet.ControlNet(c_in=t2i_data['backbone.0.0.weight'].shape[1], proj_blocks=[0, 4, 8, 12, 51, 55, 59, 63]) compression_ratio = 32 upscale_algorithm = 'bilinear' elif "backbone.10.blocks.0.weight" in keys: - model_ad = comfy.ldm.cascade.controlnet.ControlNet(c_in=t2i_data['backbone.0.weight'].shape[1], bottleneck_mode="large", proj_blocks=[0, 4, 8, 12, 51, 55, 59, 63]) + model_ad = seap.ldm.cascade.controlnet.ControlNet(c_in=t2i_data['backbone.0.weight'].shape[1], bottleneck_mode="large", proj_blocks=[0, 4, 8, 12, 51, 55, 59, 63]) compression_ratio = 1 upscale_algorithm = 'nearest-exact' else: diff --git a/comfy/diffusers_convert.py b/seap/diffusers_convert.py similarity index 100% rename from comfy/diffusers_convert.py rename to seap/diffusers_convert.py diff --git a/comfy/diffusers_load.py b/seap/diffusers_load.py similarity index 82% rename from comfy/diffusers_load.py rename to seap/diffusers_load.py index 56e63a756..bd3f47ef0 100644 --- a/comfy/diffusers_load.py +++ b/seap/diffusers_load.py @@ -1,6 +1,6 @@ import os -import comfy.sd +import seap.sd def first_file(path, filenames): for f in filenames: @@ -22,15 +22,15 @@ def load_diffusers(model_path, output_vae=True, output_clip=True, embedding_dire if text_encoder2_path is not None: text_encoder_paths.append(text_encoder2_path) - unet = comfy.sd.load_diffusion_model(unet_path) + unet = seap.sd.load_diffusion_model(unet_path) clip = None if output_clip: - clip = comfy.sd.load_clip(text_encoder_paths, embedding_directory=embedding_directory) + clip = seap.sd.load_clip(text_encoder_paths, embedding_directory=embedding_directory) vae = None if output_vae: - sd = comfy.utils.load_torch_file(vae_path) - vae = comfy.sd.VAE(sd=sd) + sd = seap.utils.load_torch_file(vae_path) + vae = seap.sd.VAE(sd=sd) return (unet, clip, vae) diff --git a/comfy/extra_samplers/uni_pc.py b/seap/extra_samplers/uni_pc.py similarity index 100% rename from comfy/extra_samplers/uni_pc.py rename to seap/extra_samplers/uni_pc.py diff --git a/comfy/float.py b/seap/float.py similarity index 100% rename from comfy/float.py rename to seap/float.py diff --git a/comfy/gligen.py b/seap/gligen.py similarity index 99% rename from comfy/gligen.py rename to seap/gligen.py index 592522767..e38447958 100644 --- a/comfy/gligen.py +++ b/seap/gligen.py @@ -2,8 +2,8 @@ import torch from torch import nn from .ldm.modules.attention import CrossAttention from inspect import isfunction -import comfy.ops -ops = comfy.ops.manual_cast +import seap.ops +ops = seap.ops.manual_cast def exists(val): return val is not None diff --git a/comfy/k_diffusion/deis.py b/seap/k_diffusion/deis.py similarity index 100% rename from comfy/k_diffusion/deis.py rename to seap/k_diffusion/deis.py diff --git a/comfy/k_diffusion/sampling.py b/seap/k_diffusion/sampling.py similarity index 98% rename from comfy/k_diffusion/sampling.py rename to seap/k_diffusion/sampling.py index 7b54d8c5a..a45224e26 100644 --- a/comfy/k_diffusion/sampling.py +++ b/seap/k_diffusion/sampling.py @@ -8,8 +8,8 @@ from tqdm.auto import trange, tqdm from . import utils from . import deis -import comfy.model_patcher -import comfy.model_sampling +import seap.model_patcher +import seap.model_sampling def append_zero(x): return torch.cat([x, x.new_zeros([1])]) @@ -521,7 +521,7 @@ def sample_dpm_adaptive(model, x, sigma_min, sigma_max, extra_args=None, callbac @torch.no_grad() def sample_dpmpp_2s_ancestral(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1., s_noise=1., noise_sampler=None): - if isinstance(model.inner_model.inner_model.model_sampling, comfy.model_sampling.CONST): + if isinstance(model.inner_model.inner_model.model_sampling, seap.model_sampling.CONST): return sample_dpmpp_2s_ancestral_RF(model, x, sigmas, extra_args, callback, disable, eta, s_noise, noise_sampler) """Ancestral sampling with DPM-Solver++(2S) second-order steps.""" @@ -1071,7 +1071,7 @@ def sample_euler_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disabl return args["denoised"] model_options = extra_args.get("model_options", {}).copy() - extra_args["model_options"] = comfy.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) + extra_args["model_options"] = seap.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) s_in = x.new_ones([x.shape[0]]) for i in trange(len(sigmas) - 1, disable=disable): @@ -1096,7 +1096,7 @@ def sample_euler_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback=No return args["denoised"] model_options = extra_args.get("model_options", {}).copy() - extra_args["model_options"] = comfy.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) + extra_args["model_options"] = seap.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) s_in = x.new_ones([x.shape[0]]) for i in trange(len(sigmas) - 1, disable=disable): @@ -1122,7 +1122,7 @@ def sample_dpmpp_2s_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback return args["denoised"] model_options = extra_args.get("model_options", {}).copy() - extra_args["model_options"] = comfy.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) + extra_args["model_options"] = seap.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) s_in = x.new_ones([x.shape[0]]) sigma_fn = lambda t: t.neg().exp() @@ -1167,7 +1167,7 @@ def sample_dpmpp_2m_cfg_pp(model, x, sigmas, extra_args=None, callback=None, dis return args["denoised"] model_options = extra_args.get("model_options", {}).copy() - extra_args["model_options"] = comfy.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) + extra_args["model_options"] = seap.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) for i in trange(len(sigmas) - 1, disable=disable): denoised = model(x, sigmas[i] * s_in, **extra_args) diff --git a/comfy/k_diffusion/utils.py b/seap/k_diffusion/utils.py similarity index 100% rename from comfy/k_diffusion/utils.py rename to seap/k_diffusion/utils.py diff --git a/comfy/latent_formats.py b/seap/latent_formats.py similarity index 100% rename from comfy/latent_formats.py rename to seap/latent_formats.py diff --git a/comfy/ldm/audio/autoencoder.py b/seap/ldm/audio/autoencoder.py similarity index 99% rename from comfy/ldm/audio/autoencoder.py rename to seap/ldm/audio/autoencoder.py index 8123e66a5..d9e48685b 100644 --- a/comfy/ldm/audio/autoencoder.py +++ b/seap/ldm/audio/autoencoder.py @@ -4,8 +4,8 @@ import torch from torch import nn from typing import Literal, Dict, Any import math -import comfy.ops -ops = comfy.ops.disable_weight_init +import seap.ops +ops = seap.ops.disable_weight_init def vae_sample(mean, scale): stdev = nn.functional.softplus(scale) + 1e-4 diff --git a/comfy/ldm/audio/dit.py b/seap/ldm/audio/dit.py similarity index 98% rename from comfy/ldm/audio/dit.py rename to seap/ldm/audio/dit.py index 4d2185be8..449985ff1 100644 --- a/comfy/ldm/audio/dit.py +++ b/seap/ldm/audio/dit.py @@ -1,6 +1,6 @@ # code adapted from: https://github.com/Stability-AI/stable-audio-tools -from comfy.ldm.modules.attention import optimized_attention +from seap.ldm.modules.attention import optimized_attention import typing as tp import torch @@ -9,7 +9,7 @@ from einops import rearrange from torch import nn from torch.nn import functional as F import math -import comfy.ops +import seap.ops class FourierFeatures(nn.Module): def __init__(self, in_features, out_features, std=1., dtype=None, device=None): @@ -19,7 +19,7 @@ class FourierFeatures(nn.Module): [out_features // 2, in_features], dtype=dtype, device=device)) def forward(self, input): - f = 2 * math.pi * input @ comfy.ops.cast_to_input(self.weight.T, input) + f = 2 * math.pi * input @ seap.ops.cast_to_input(self.weight.T, input) return torch.cat([f.cos(), f.sin()], dim=-1) # norms @@ -40,8 +40,8 @@ class LayerNorm(nn.Module): def forward(self, x): beta = self.beta if beta is not None: - beta = comfy.ops.cast_to_input(beta, x) - return F.layer_norm(x, x.shape[-1:], weight=comfy.ops.cast_to_input(self.gamma, x), bias=beta) + beta = seap.ops.cast_to_input(beta, x) + return F.layer_norm(x, x.shape[-1:], weight=seap.ops.cast_to_input(self.gamma, x), bias=beta) class GLU(nn.Module): def __init__( @@ -164,14 +164,14 @@ class RotaryEmbedding(nn.Module): t = t / self.interpolation_factor - freqs = torch.einsum('i , j -> i j', t, comfy.ops.cast_to_input(self.inv_freq, t)) + freqs = torch.einsum('i , j -> i j', t, seap.ops.cast_to_input(self.inv_freq, t)) freqs = torch.cat((freqs, freqs), dim = -1) if self.scale is None: return freqs, 1. power = (torch.arange(seq_len, device = device) - (seq_len // 2)) / self.scale_base - scale = comfy.ops.cast_to_input(self.scale, t) ** rearrange(power, 'n -> n 1') + scale = seap.ops.cast_to_input(self.scale, t) ** rearrange(power, 'n -> n 1') scale = torch.cat((scale, scale), dim = -1) return freqs, scale diff --git a/comfy/ldm/audio/embedders.py b/seap/ldm/audio/embedders.py similarity index 97% rename from comfy/ldm/audio/embedders.py rename to seap/ldm/audio/embedders.py index 82a3210c6..e67840247 100644 --- a/comfy/ldm/audio/embedders.py +++ b/seap/ldm/audio/embedders.py @@ -6,7 +6,7 @@ from torch import Tensor, einsum from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, TypeVar, Union from einops import rearrange import math -import comfy.ops +import seap.ops class LearnedPositionalEmbedding(nn.Module): """Used for continuous time""" @@ -27,7 +27,7 @@ class LearnedPositionalEmbedding(nn.Module): def TimePositionalEmbedding(dim: int, out_features: int) -> nn.Module: return nn.Sequential( LearnedPositionalEmbedding(dim), - comfy.ops.manual_cast.Linear(in_features=dim + 1, out_features=out_features), + seap.ops.manual_cast.Linear(in_features=dim + 1, out_features=out_features), ) diff --git a/comfy/ldm/aura/mmdit.py b/seap/ldm/aura/mmdit.py similarity index 97% rename from comfy/ldm/aura/mmdit.py rename to seap/ldm/aura/mmdit.py index cd9a42185..7ced45cc5 100644 --- a/comfy/ldm/aura/mmdit.py +++ b/seap/ldm/aura/mmdit.py @@ -7,9 +7,9 @@ import torch import torch.nn as nn import torch.nn.functional as F -from comfy.ldm.modules.attention import optimized_attention -import comfy.ops -import comfy.ldm.common_dit +from seap.ldm.modules.attention import optimized_attention +import seap.ops +import seap.ldm.common_dit def modulate(x, shift, scale): return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1) @@ -408,7 +408,7 @@ class MMDiT(nn.Module): def patchify(self, x): B, C, H, W = x.size() - x = comfy.ldm.common_dit.pad_to_patch_size(x, (self.patch_size, self.patch_size)) + x = seap.ldm.common_dit.pad_to_patch_size(x, (self.patch_size, self.patch_size)) x = x.view( B, C, @@ -426,7 +426,7 @@ class MMDiT(nn.Module): max_dim = max(h, w) cur_dim = self.h_max - pos_encoding = comfy.ops.cast_to_input(self.positional_encoding.reshape(1, cur_dim, cur_dim, -1), x) + pos_encoding = seap.ops.cast_to_input(self.positional_encoding.reshape(1, cur_dim, cur_dim, -1), x) if max_dim > cur_dim: pos_encoding = F.interpolate(pos_encoding.movedim(-1, 1), (max_dim, max_dim), mode="bilinear").movedim(1, -1) @@ -454,7 +454,7 @@ class MMDiT(nn.Module): t = timestep c = self.cond_seq_linear(c_seq) # B, T_c, D - c = torch.cat([comfy.ops.cast_to_input(self.register_tokens, c).repeat(c.size(0), 1, 1), c], dim=1) + c = torch.cat([seap.ops.cast_to_input(self.register_tokens, c).repeat(c.size(0), 1, 1), c], dim=1) global_cond = self.t_embedder(t, x.dtype) # B, D diff --git a/comfy/ldm/cascade/common.py b/seap/ldm/cascade/common.py similarity index 97% rename from comfy/ldm/cascade/common.py rename to seap/ldm/cascade/common.py index 3eaa0c821..d263d08f7 100644 --- a/comfy/ldm/cascade/common.py +++ b/seap/ldm/cascade/common.py @@ -18,8 +18,8 @@ import torch import torch.nn as nn -from comfy.ldm.modules.attention import optimized_attention -import comfy.ops +from seap.ldm.modules.attention import optimized_attention +import seap.ops class OptimizedAttention(nn.Module): def __init__(self, c, nhead, dropout=0.0, dtype=None, device=None, operations=None): @@ -77,7 +77,7 @@ class GlobalResponseNorm(nn.Module): def forward(self, x): Gx = torch.norm(x, p=2, dim=(1, 2), keepdim=True) Nx = Gx / (Gx.mean(dim=-1, keepdim=True) + 1e-6) - return comfy.ops.cast_to_input(self.gamma, x) * (x * Nx) + comfy.ops.cast_to_input(self.beta, x) + x + return seap.ops.cast_to_input(self.gamma, x) * (x * Nx) + seap.ops.cast_to_input(self.beta, x) + x class ResBlock(nn.Module): diff --git a/comfy/ldm/cascade/controlnet.py b/seap/ldm/cascade/controlnet.py similarity index 100% rename from comfy/ldm/cascade/controlnet.py rename to seap/ldm/cascade/controlnet.py diff --git a/comfy/ldm/cascade/stage_a.py b/seap/ldm/cascade/stage_a.py similarity index 100% rename from comfy/ldm/cascade/stage_a.py rename to seap/ldm/cascade/stage_a.py diff --git a/comfy/ldm/cascade/stage_b.py b/seap/ldm/cascade/stage_b.py similarity index 100% rename from comfy/ldm/cascade/stage_b.py rename to seap/ldm/cascade/stage_b.py diff --git a/comfy/ldm/cascade/stage_c.py b/seap/ldm/cascade/stage_c.py similarity index 100% rename from comfy/ldm/cascade/stage_c.py rename to seap/ldm/cascade/stage_c.py diff --git a/comfy/ldm/cascade/stage_c_coder.py b/seap/ldm/cascade/stage_c_coder.py similarity index 100% rename from comfy/ldm/cascade/stage_c_coder.py rename to seap/ldm/cascade/stage_c_coder.py diff --git a/comfy/ldm/common_dit.py b/seap/ldm/common_dit.py similarity index 76% rename from comfy/ldm/common_dit.py rename to seap/ldm/common_dit.py index 5aebaf9ea..c3a94a9c2 100644 --- a/comfy/ldm/common_dit.py +++ b/seap/ldm/common_dit.py @@ -1,5 +1,5 @@ import torch -import comfy.ops +import seap.ops def pad_to_patch_size(img, patch_size=(2, 2), padding_mode="circular"): if padding_mode == "circular" and torch.jit.is_tracing() or torch.jit.is_scripting(): @@ -15,7 +15,7 @@ except: def rms_norm(x, weight, eps=1e-6): if rms_norm_torch is not None and not (torch.jit.is_tracing() or torch.jit.is_scripting()): - return rms_norm_torch(x, weight.shape, weight=comfy.ops.cast_to(weight, dtype=x.dtype, device=x.device), eps=eps) + return rms_norm_torch(x, weight.shape, weight=seap.ops.cast_to(weight, dtype=x.dtype, device=x.device), eps=eps) else: rrms = torch.rsqrt(torch.mean(x**2, dim=-1, keepdim=True) + eps) - return (x * rrms) * comfy.ops.cast_to(weight, dtype=x.dtype, device=x.device) + return (x * rrms) * seap.ops.cast_to(weight, dtype=x.dtype, device=x.device) diff --git a/comfy/ldm/flux/controlnet.py b/seap/ldm/flux/controlnet.py similarity index 97% rename from comfy/ldm/flux/controlnet.py rename to seap/ldm/flux/controlnet.py index c033dea52..b9230c3b9 100644 --- a/comfy/ldm/flux/controlnet.py +++ b/seap/ldm/flux/controlnet.py @@ -11,7 +11,7 @@ from .layers import (DoubleStreamBlock, EmbedND, LastLayer, timestep_embedding) from .model import Flux -import comfy.ldm.common_dit +import seap.ldm.common_dit class MistolineCondDownsamplBlock(nn.Module): def __init__(self, dtype=None, device=None, operations=None): @@ -179,7 +179,7 @@ class ControlNetFlux(Flux): def forward(self, x, timesteps, context, y, guidance=None, hint=None, **kwargs): patch_size = 2 if self.latent_input: - hint = comfy.ldm.common_dit.pad_to_patch_size(hint, (patch_size, patch_size)) + hint = seap.ldm.common_dit.pad_to_patch_size(hint, (patch_size, patch_size)) elif self.mistoline: hint = hint * 2.0 - 1.0 hint = self.input_cond_block(hint) @@ -190,7 +190,7 @@ class ControlNetFlux(Flux): hint = rearrange(hint, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=patch_size, pw=patch_size) bs, c, h, w = x.shape - x = comfy.ldm.common_dit.pad_to_patch_size(x, (patch_size, patch_size)) + x = seap.ldm.common_dit.pad_to_patch_size(x, (patch_size, patch_size)) img = rearrange(x, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=patch_size, pw=patch_size) diff --git a/comfy/ldm/flux/layers.py b/seap/ldm/flux/layers.py similarity index 98% rename from comfy/ldm/flux/layers.py rename to seap/ldm/flux/layers.py index dabab3e33..39424b583 100644 --- a/comfy/ldm/flux/layers.py +++ b/seap/ldm/flux/layers.py @@ -5,8 +5,8 @@ import torch from torch import Tensor, nn from .math import attention, rope -import comfy.ops -import comfy.ldm.common_dit +import seap.ops +import seap.ldm.common_dit class EmbedND(nn.Module): @@ -64,7 +64,7 @@ class RMSNorm(torch.nn.Module): self.scale = nn.Parameter(torch.empty((dim), dtype=dtype, device=device)) def forward(self, x: Tensor): - return comfy.ldm.common_dit.rms_norm(x, self.scale, 1e-6) + return seap.ldm.common_dit.rms_norm(x, self.scale, 1e-6) class QKNorm(torch.nn.Module): diff --git a/comfy/ldm/flux/math.py b/seap/ldm/flux/math.py similarity index 87% rename from comfy/ldm/flux/math.py rename to seap/ldm/flux/math.py index 136ce2aa8..30b53e1c8 100644 --- a/comfy/ldm/flux/math.py +++ b/seap/ldm/flux/math.py @@ -1,8 +1,8 @@ import torch from einops import rearrange from torch import Tensor -from comfy.ldm.modules.attention import optimized_attention -import comfy.model_management +from seap.ldm.modules.attention import optimized_attention +import seap.model_management def attention(q: Tensor, k: Tensor, v: Tensor, pe: Tensor) -> Tensor: q, k = apply_rope(q, k, pe) @@ -14,7 +14,7 @@ def attention(q: Tensor, k: Tensor, v: Tensor, pe: Tensor) -> Tensor: def rope(pos: Tensor, dim: int, theta: int) -> Tensor: assert dim % 2 == 0 - if comfy.model_management.is_device_mps(pos.device) or comfy.model_management.is_intel_xpu(): + if seap.model_management.is_device_mps(pos.device) or seap.model_management.is_intel_xpu(): device = torch.device("cpu") else: device = pos.device diff --git a/comfy/ldm/flux/model.py b/seap/ldm/flux/model.py similarity index 98% rename from comfy/ldm/flux/model.py rename to seap/ldm/flux/model.py index b7d8a692d..c1f5ccf50 100644 --- a/comfy/ldm/flux/model.py +++ b/seap/ldm/flux/model.py @@ -15,7 +15,7 @@ from .layers import ( ) from einops import rearrange, repeat -import comfy.ldm.common_dit +import seap.ldm.common_dit @dataclass class FluxParams: @@ -144,7 +144,7 @@ class Flux(nn.Module): def forward(self, x, timestep, context, y, guidance, control=None, **kwargs): bs, c, h, w = x.shape patch_size = 2 - x = comfy.ldm.common_dit.pad_to_patch_size(x, (patch_size, patch_size)) + x = seap.ldm.common_dit.pad_to_patch_size(x, (patch_size, patch_size)) img = rearrange(x, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=patch_size, pw=patch_size) diff --git a/comfy/ldm/hydit/attn_layers.py b/seap/ldm/hydit/attn_layers.py similarity index 99% rename from comfy/ldm/hydit/attn_layers.py rename to seap/ldm/hydit/attn_layers.py index e2801f714..d9e98308c 100644 --- a/comfy/ldm/hydit/attn_layers.py +++ b/seap/ldm/hydit/attn_layers.py @@ -1,7 +1,7 @@ import torch import torch.nn as nn from typing import Tuple, Union, Optional -from comfy.ldm.modules.attention import optimized_attention +from seap.ldm.modules.attention import optimized_attention def reshape_for_broadcast(freqs_cis: Union[torch.Tensor, Tuple[torch.Tensor]], x: torch.Tensor, head_first=False): diff --git a/comfy/ldm/hydit/controlnet.py b/seap/ldm/hydit/controlnet.py similarity index 97% rename from comfy/ldm/hydit/controlnet.py rename to seap/ldm/hydit/controlnet.py index cd71fca31..2858de7aa 100644 --- a/comfy/ldm/hydit/controlnet.py +++ b/seap/ldm/hydit/controlnet.py @@ -6,16 +6,16 @@ import torch.nn.functional as F from torch.utils import checkpoint -from comfy.ldm.modules.diffusionmodules.mmdit import ( +from seap.ldm.modules.diffusionmodules.mmdit import ( Mlp, TimestepEmbedder, PatchEmbed, RMSNorm, ) -from comfy.ldm.modules.diffusionmodules.util import timestep_embedding +from seap.ldm.modules.diffusionmodules.util import timestep_embedding from .poolers import AttentionPool -import comfy.latent_formats +import seap.latent_formats from .models import HunYuanDiTBlock, calc_rope from .posemb_layers import get_2d_rotary_pos_embed, get_fill_resize_and_crop @@ -93,7 +93,7 @@ class HunYuanControlNet(nn.Module): self.use_style_cond = use_style_cond self.norm = norm self.dtype = dtype - self.latent_format = comfy.latent_formats.SDXL + self.latent_format = seap.latent_formats.SDXL self.mlp_t5 = nn.Sequential( nn.Linear( @@ -261,7 +261,7 @@ class HunYuanControlNet(nn.Module): b_t5, l_t5, c_t5 = text_states_t5.shape text_states_t5 = self.mlp_t5(text_states_t5.view(-1, c_t5)).view(b_t5, l_t5, -1) - padding = comfy.ops.cast_to_input(self.text_embedding_padding, text_states) + padding = seap.ops.cast_to_input(self.text_embedding_padding, text_states) text_states[:, -self.text_len :] = torch.where( text_states_mask[:, -self.text_len :].unsqueeze(2), diff --git a/comfy/ldm/hydit/models.py b/seap/ldm/hydit/models.py similarity index 98% rename from comfy/ldm/hydit/models.py rename to seap/ldm/hydit/models.py index 44e806cba..064ff58e1 100644 --- a/comfy/ldm/hydit/models.py +++ b/seap/ldm/hydit/models.py @@ -4,9 +4,9 @@ import torch import torch.nn as nn import torch.nn.functional as F -import comfy.ops -from comfy.ldm.modules.diffusionmodules.mmdit import Mlp, TimestepEmbedder, PatchEmbed, RMSNorm -from comfy.ldm.modules.diffusionmodules.util import timestep_embedding +import seap.ops +from seap.ldm.modules.diffusionmodules.mmdit import Mlp, TimestepEmbedder, PatchEmbed, RMSNorm +from seap.ldm.modules.diffusionmodules.util import timestep_embedding from torch.utils import checkpoint from .attn_layers import Attention, CrossAttention @@ -325,7 +325,7 @@ class HunYuanDiT(nn.Module): b_t5, l_t5, c_t5 = text_states_t5.shape text_states_t5 = self.mlp_t5(text_states_t5.view(-1, c_t5)).view(b_t5, l_t5, -1) - padding = comfy.ops.cast_to_input(self.text_embedding_padding, text_states) + padding = seap.ops.cast_to_input(self.text_embedding_padding, text_states) text_states[:,-self.text_len:] = torch.where(text_states_mask[:,-self.text_len:].unsqueeze(2), text_states[:,-self.text_len:], padding[:self.text_len]) text_states_t5[:,-self.text_len_t5:] = torch.where(text_states_t5_mask[:,-self.text_len_t5:].unsqueeze(2), text_states_t5[:,-self.text_len_t5:], padding[self.text_len:]) diff --git a/comfy/ldm/hydit/poolers.py b/seap/ldm/hydit/poolers.py similarity index 91% rename from comfy/ldm/hydit/poolers.py rename to seap/ldm/hydit/poolers.py index f5e5b406f..e47655385 100644 --- a/comfy/ldm/hydit/poolers.py +++ b/seap/ldm/hydit/poolers.py @@ -1,8 +1,8 @@ import torch import torch.nn as nn import torch.nn.functional as F -from comfy.ldm.modules.attention import optimized_attention -import comfy.ops +from seap.ldm.modules.attention import optimized_attention +import seap.ops class AttentionPool(nn.Module): def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None, dtype=None, device=None, operations=None): @@ -19,7 +19,7 @@ class AttentionPool(nn.Module): x = x[:,:self.positional_embedding.shape[0] - 1] x = x.permute(1, 0, 2) # NLC -> LNC x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (L+1)NC - x = x + comfy.ops.cast_to_input(self.positional_embedding[:, None, :], x) # (L+1)NC + x = x + seap.ops.cast_to_input(self.positional_embedding[:, None, :], x) # (L+1)NC q = self.q_proj(x[:1]) k = self.k_proj(x) diff --git a/comfy/ldm/hydit/posemb_layers.py b/seap/ldm/hydit/posemb_layers.py similarity index 100% rename from comfy/ldm/hydit/posemb_layers.py rename to seap/ldm/hydit/posemb_layers.py diff --git a/comfy/ldm/models/autoencoder.py b/seap/ldm/models/autoencoder.py similarity index 92% rename from comfy/ldm/models/autoencoder.py rename to seap/ldm/models/autoencoder.py index f5f4de288..12aa58b25 100644 --- a/comfy/ldm/models/autoencoder.py +++ b/seap/ldm/models/autoencoder.py @@ -2,11 +2,11 @@ import torch from contextlib import contextmanager from typing import Any, Dict, List, Optional, Tuple, Union -from comfy.ldm.modules.distributions.distributions import DiagonalGaussianDistribution +from seap.ldm.modules.distributions.distributions import DiagonalGaussianDistribution -from comfy.ldm.util import instantiate_from_config -from comfy.ldm.modules.ema import LitEma -import comfy.ops +from seap.ldm.util import instantiate_from_config +from seap.ldm.modules.ema import LitEma +import seap.ops class DiagonalGaussianRegularizer(torch.nn.Module): def __init__(self, sample: bool = True): @@ -151,21 +151,21 @@ class AutoencodingEngineLegacy(AutoencodingEngine): ddconfig = kwargs.pop("ddconfig") super().__init__( encoder_config={ - "target": "comfy.ldm.modules.diffusionmodules.model.Encoder", + "target": "seap.ldm.modules.diffusionmodules.model.Encoder", "params": ddconfig, }, decoder_config={ - "target": "comfy.ldm.modules.diffusionmodules.model.Decoder", + "target": "seap.ldm.modules.diffusionmodules.model.Decoder", "params": ddconfig, }, **kwargs, ) - self.quant_conv = comfy.ops.disable_weight_init.Conv2d( + self.quant_conv = seap.ops.disable_weight_init.Conv2d( (1 + ddconfig["double_z"]) * ddconfig["z_channels"], (1 + ddconfig["double_z"]) * embed_dim, 1, ) - self.post_quant_conv = comfy.ops.disable_weight_init.Conv2d(embed_dim, ddconfig["z_channels"], 1) + self.post_quant_conv = seap.ops.disable_weight_init.Conv2d(embed_dim, ddconfig["z_channels"], 1) self.embed_dim = embed_dim def get_autoencoder_params(self) -> list: @@ -219,7 +219,7 @@ class AutoencoderKL(AutoencodingEngineLegacy): super().__init__( regularizer_config={ "target": ( - "comfy.ldm.models.autoencoder.DiagonalGaussianRegularizer" + "seap.ldm.models.autoencoder.DiagonalGaussianRegularizer" ) }, **kwargs, diff --git a/comfy/ldm/modules/attention.py b/seap/ldm/modules/attention.py similarity index 99% rename from comfy/ldm/modules/attention.py rename to seap/ldm/modules/attention.py index 85ea406e0..a49c7d2ed 100644 --- a/comfy/ldm/modules/attention.py +++ b/seap/ldm/modules/attention.py @@ -9,15 +9,15 @@ import logging from .diffusionmodules.util import AlphaBlender, timestep_embedding from .sub_quadratic_attention import efficient_dot_product_attention -from comfy import model_management +from seap import model_management if model_management.xformers_enabled(): import xformers import xformers.ops -from comfy.cli_args import args -import comfy.ops -ops = comfy.ops.disable_weight_init +from seap.cli_args import args +import seap.ops +ops = seap.ops.disable_weight_init FORCE_UPCAST_ATTENTION_DTYPE = model_management.force_upcast_attention_dtype() diff --git a/comfy/ldm/modules/diffusionmodules/__init__.py b/seap/ldm/modules/diffusionmodules/__init__.py similarity index 100% rename from comfy/ldm/modules/diffusionmodules/__init__.py rename to seap/ldm/modules/diffusionmodules/__init__.py diff --git a/comfy/ldm/modules/diffusionmodules/mmdit.py b/seap/ldm/modules/diffusionmodules/mmdit.py similarity index 99% rename from comfy/ldm/modules/diffusionmodules/mmdit.py rename to seap/ldm/modules/diffusionmodules/mmdit.py index 759788a97..9e356e668 100644 --- a/comfy/ldm/modules/diffusionmodules/mmdit.py +++ b/seap/ldm/modules/diffusionmodules/mmdit.py @@ -8,8 +8,8 @@ import torch.nn as nn from .. import attention from einops import rearrange, repeat from .util import timestep_embedding -import comfy.ops -import comfy.ldm.common_dit +import seap.ops +import seap.ldm.common_dit def default(x, y): if x is not None: @@ -112,7 +112,7 @@ class PatchEmbed(nn.Module): # f"Input width ({W}) should be divisible by patch size ({self.patch_size[1]})." # ) if self.dynamic_img_pad: - x = comfy.ldm.common_dit.pad_to_patch_size(x, self.patch_size, padding_mode=self.padding_mode) + x = seap.ldm.common_dit.pad_to_patch_size(x, self.patch_size, padding_mode=self.padding_mode) x = self.proj(x) if self.flatten: x = x.flatten(2).transpose(1, 2) # NCHW -> NLC @@ -356,7 +356,7 @@ class RMSNorm(torch.nn.Module): self.register_parameter("weight", None) def forward(self, x): - return comfy.ldm.common_dit.rms_norm(x, self.weight, self.eps) + return seap.ldm.common_dit.rms_norm(x, self.weight, self.eps) @@ -906,7 +906,7 @@ class MMDiT(nn.Module): context = self.context_processor(context) hw = x.shape[-2:] - x = self.x_embedder(x) + comfy.ops.cast_to_input(self.cropped_pos_embed(hw, device=x.device), x) + x = self.x_embedder(x) + seap.ops.cast_to_input(self.cropped_pos_embed(hw, device=x.device), x) c = self.t_embedder(t, dtype=x.dtype) # (N, D) if y is not None and self.y_embedder is not None: y = self.y_embedder(y) # (N, D) diff --git a/comfy/ldm/modules/diffusionmodules/model.py b/seap/ldm/modules/diffusionmodules/model.py similarity index 99% rename from comfy/ldm/modules/diffusionmodules/model.py rename to seap/ldm/modules/diffusionmodules/model.py index 04eb83b21..6eb7245e0 100644 --- a/comfy/ldm/modules/diffusionmodules/model.py +++ b/seap/ldm/modules/diffusionmodules/model.py @@ -6,9 +6,9 @@ import numpy as np from typing import Optional, Any import logging -from comfy import model_management -import comfy.ops -ops = comfy.ops.disable_weight_init +from seap import model_management +import seap.ops +ops = seap.ops.disable_weight_init if model_management.xformers_enabled_vae(): import xformers diff --git a/comfy/ldm/modules/diffusionmodules/openaimodel.py b/seap/ldm/modules/diffusionmodules/openaimodel.py similarity index 99% rename from comfy/ldm/modules/diffusionmodules/openaimodel.py rename to seap/ldm/modules/diffusionmodules/openaimodel.py index 2902073d5..768572bbb 100644 --- a/comfy/ldm/modules/diffusionmodules/openaimodel.py +++ b/seap/ldm/modules/diffusionmodules/openaimodel.py @@ -14,9 +14,9 @@ from .util import ( AlphaBlender, ) from ..attention import SpatialTransformer, SpatialVideoTransformer, default -from comfy.ldm.util import exists -import comfy.ops -ops = comfy.ops.disable_weight_init +from seap.ldm.util import exists +import seap.ops +ops = seap.ops.disable_weight_init class TimestepBlock(nn.Module): """ diff --git a/comfy/ldm/modules/diffusionmodules/upscaling.py b/seap/ldm/modules/diffusionmodules/upscaling.py similarity index 99% rename from comfy/ldm/modules/diffusionmodules/upscaling.py rename to seap/ldm/modules/diffusionmodules/upscaling.py index f5ac7c2f9..bea752033 100644 --- a/comfy/ldm/modules/diffusionmodules/upscaling.py +++ b/seap/ldm/modules/diffusionmodules/upscaling.py @@ -4,7 +4,7 @@ import numpy as np from functools import partial from .util import extract_into_tensor, make_beta_schedule -from comfy.ldm.util import default +from seap.ldm.util import default class AbstractLowScaleModel(nn.Module): diff --git a/comfy/ldm/modules/diffusionmodules/util.py b/seap/ldm/modules/diffusionmodules/util.py similarity index 99% rename from comfy/ldm/modules/diffusionmodules/util.py rename to seap/ldm/modules/diffusionmodules/util.py index ce14ad5e1..83bd07b22 100644 --- a/comfy/ldm/modules/diffusionmodules/util.py +++ b/seap/ldm/modules/diffusionmodules/util.py @@ -15,7 +15,7 @@ import torch.nn as nn import numpy as np from einops import repeat, rearrange -from comfy.ldm.util import instantiate_from_config +from seap.ldm.util import instantiate_from_config class AlphaBlender(nn.Module): strategies = ["learned", "fixed", "learned_with_images"] diff --git a/comfy/ldm/modules/distributions/__init__.py b/seap/ldm/modules/distributions/__init__.py similarity index 100% rename from comfy/ldm/modules/distributions/__init__.py rename to seap/ldm/modules/distributions/__init__.py diff --git a/comfy/ldm/modules/distributions/distributions.py b/seap/ldm/modules/distributions/distributions.py similarity index 100% rename from comfy/ldm/modules/distributions/distributions.py rename to seap/ldm/modules/distributions/distributions.py diff --git a/comfy/ldm/modules/ema.py b/seap/ldm/modules/ema.py similarity index 100% rename from comfy/ldm/modules/ema.py rename to seap/ldm/modules/ema.py diff --git a/comfy/ldm/modules/encoders/__init__.py b/seap/ldm/modules/encoders/__init__.py similarity index 100% rename from comfy/ldm/modules/encoders/__init__.py rename to seap/ldm/modules/encoders/__init__.py diff --git a/comfy/ldm/modules/encoders/noise_aug_modules.py b/seap/ldm/modules/encoders/noise_aug_modules.py similarity index 100% rename from comfy/ldm/modules/encoders/noise_aug_modules.py rename to seap/ldm/modules/encoders/noise_aug_modules.py diff --git a/comfy/ldm/modules/sub_quadratic_attention.py b/seap/ldm/modules/sub_quadratic_attention.py similarity index 99% rename from comfy/ldm/modules/sub_quadratic_attention.py rename to seap/ldm/modules/sub_quadratic_attention.py index 1bc4138c3..bae879cfb 100644 --- a/comfy/ldm/modules/sub_quadratic_attention.py +++ b/seap/ldm/modules/sub_quadratic_attention.py @@ -25,7 +25,7 @@ except ImportError: from torch import Tensor from typing import List -from comfy import model_management +from seap import model_management def dynamic_slice( x: Tensor, diff --git a/comfy/ldm/modules/temporal_ae.py b/seap/ldm/modules/temporal_ae.py similarity index 99% rename from comfy/ldm/modules/temporal_ae.py rename to seap/ldm/modules/temporal_ae.py index 2992aeafc..f173384f1 100644 --- a/comfy/ldm/modules/temporal_ae.py +++ b/seap/ldm/modules/temporal_ae.py @@ -4,8 +4,8 @@ from typing import Callable, Iterable, Union import torch from einops import rearrange, repeat -import comfy.ops -ops = comfy.ops.disable_weight_init +import seap.ops +ops = seap.ops.disable_weight_init from .diffusionmodules.model import ( AttnBlock, diff --git a/comfy/ldm/util.py b/seap/ldm/util.py similarity index 100% rename from comfy/ldm/util.py rename to seap/ldm/util.py diff --git a/comfy/lora.py b/seap/lora.py similarity index 85% rename from comfy/lora.py rename to seap/lora.py index 80057cdd4..46166467a 100644 --- a/comfy/lora.py +++ b/seap/lora.py @@ -17,9 +17,9 @@ """ from __future__ import annotations -import comfy.utils -import comfy.model_management -import comfy.model_base +import seap.utils +import seap.model_management +import seap.model_base import logging import torch @@ -288,7 +288,7 @@ def model_lora_keys_unet(model, key_map={}): key_map["lora_prior_unet_{}".format(key_lora)] = k #cascade lora: TODO put lora key prefix in the model config key_map["{}".format(k[:-len(".weight")])] = k #generic lora format without any weird key names - diffusers_keys = comfy.utils.unet_to_diffusers(model.model_config.unet_config) + diffusers_keys = seap.utils.unet_to_diffusers(model.model_config.unet_config) for k in diffusers_keys: if k.endswith(".weight"): unet_key = "diffusion_model.{}".format(diffusers_keys[k]) @@ -303,8 +303,8 @@ def model_lora_keys_unet(model, key_map={}): diffusers_lora_key = diffusers_lora_key[:-2] key_map[diffusers_lora_key] = unet_key - if isinstance(model, comfy.model_base.SD3): #Diffusers lora SD3 - diffusers_keys = comfy.utils.mmdit_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") + if isinstance(model, seap.model_base.SD3): #Diffusers lora SD3 + diffusers_keys = seap.utils.mmdit_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") for k in diffusers_keys: if k.endswith(".weight"): to = diffusers_keys[k] @@ -317,22 +317,22 @@ def model_lora_keys_unet(model, key_map={}): key_lora = "lora_transformer_{}".format(k[:-len(".weight")].replace(".", "_")) #OneTrainer lora key_map[key_lora] = to - if isinstance(model, comfy.model_base.AuraFlow): #Diffusers lora AuraFlow - diffusers_keys = comfy.utils.auraflow_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") + if isinstance(model, seap.model_base.AuraFlow): #Diffusers lora AuraFlow + diffusers_keys = seap.utils.auraflow_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") for k in diffusers_keys: if k.endswith(".weight"): to = diffusers_keys[k] key_lora = "transformer.{}".format(k[:-len(".weight")]) #simpletrainer and probably regular diffusers lora format key_map[key_lora] = to - if isinstance(model, comfy.model_base.HunyuanDiT): + if isinstance(model, seap.model_base.HunyuanDiT): for k in sdk: if k.startswith("diffusion_model.") and k.endswith(".weight"): key_lora = k[len("diffusion_model."):-len(".weight")] key_map["base_model.model.{}".format(key_lora)] = k #official hunyuan lora format - if isinstance(model, comfy.model_base.Flux): #Diffusers lora Flux - diffusers_keys = comfy.utils.flux_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") + if isinstance(model, seap.model_base.Flux): #Diffusers lora Flux + diffusers_keys = seap.utils.flux_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.") for k in diffusers_keys: if k.endswith(".weight"): to = diffusers_keys[k] @@ -344,7 +344,7 @@ def model_lora_keys_unet(model, key_map={}): def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function): - dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype) + dora_scale = seap.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype) lora_diff *= alpha weight_calc = weight + function(lora_diff).type(weight.dtype) weight_norm = ( @@ -415,7 +415,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): weight *= strength_model if isinstance(v, list): - v = (calculate_weight(v[1:], comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype, copy=True), key, intermediate_dtype=intermediate_dtype), ) + v = (calculate_weight(v[1:], seap.model_management.cast_to_device(v[0], weight.device, intermediate_dtype, copy=True), key, intermediate_dtype=intermediate_dtype),) if len(v) == 1: patch_type = "diff" @@ -435,10 +435,10 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): if diff.shape != weight.shape: logging.warning("WARNING SHAPE MISMATCH {} WEIGHT NOT MERGED {} != {}".format(key, diff.shape, weight.shape)) else: - weight += function(strength * comfy.model_management.cast_to_device(diff, weight.device, weight.dtype)) + weight += function(strength * seap.model_management.cast_to_device(diff, weight.device, weight.dtype)) elif patch_type == "lora": #lora/locon - mat1 = comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype) - mat2 = comfy.model_management.cast_to_device(v[1], weight.device, intermediate_dtype) + mat1 = seap.model_management.cast_to_device(v[0], weight.device, intermediate_dtype) + mat2 = seap.model_management.cast_to_device(v[1], weight.device, intermediate_dtype) dora_scale = v[4] if v[2] is not None: alpha = v[2] / mat2.shape[0] @@ -447,7 +447,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): if v[3] is not None: #locon mid weights, hopefully the math is fine because I didn't properly test it - mat3 = comfy.model_management.cast_to_device(v[3], weight.device, intermediate_dtype) + mat3 = seap.model_management.cast_to_device(v[3], weight.device, intermediate_dtype) final_shape = [mat2.shape[1], mat2.shape[0], mat3.shape[2], mat3.shape[3]] mat2 = torch.mm(mat2.transpose(0, 1).flatten(start_dim=1), mat3.transpose(0, 1).flatten(start_dim=1)).reshape(final_shape).transpose(0, 1) try: @@ -471,23 +471,23 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): if w1 is None: dim = w1_b.shape[0] - w1 = torch.mm(comfy.model_management.cast_to_device(w1_a, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w1_b, weight.device, intermediate_dtype)) + w1 = torch.mm(seap.model_management.cast_to_device(w1_a, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w1_b, weight.device, intermediate_dtype)) else: - w1 = comfy.model_management.cast_to_device(w1, weight.device, intermediate_dtype) + w1 = seap.model_management.cast_to_device(w1, weight.device, intermediate_dtype) if w2 is None: dim = w2_b.shape[0] if t2 is None: - w2 = torch.mm(comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype)) + w2 = torch.mm(seap.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype)) else: w2 = torch.einsum('i j k l, j r, i p -> p r k l', - comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype)) + seap.model_management.cast_to_device(t2, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2_b, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2_a, weight.device, intermediate_dtype)) else: - w2 = comfy.model_management.cast_to_device(w2, weight.device, intermediate_dtype) + w2 = seap.model_management.cast_to_device(w2, weight.device, intermediate_dtype) if len(w2.shape) == 4: w1 = w1.unsqueeze(2).unsqueeze(2) @@ -519,19 +519,19 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): t1 = v[5] t2 = v[6] m1 = torch.einsum('i j k l, j r, i p -> p r k l', - comfy.model_management.cast_to_device(t1, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype)) + seap.model_management.cast_to_device(t1, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w1b, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w1a, weight.device, intermediate_dtype)) m2 = torch.einsum('i j k l, j r, i p -> p r k l', - comfy.model_management.cast_to_device(t2, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype)) + seap.model_management.cast_to_device(t2, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2b, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2a, weight.device, intermediate_dtype)) else: - m1 = torch.mm(comfy.model_management.cast_to_device(w1a, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w1b, weight.device, intermediate_dtype)) - m2 = torch.mm(comfy.model_management.cast_to_device(w2a, weight.device, intermediate_dtype), - comfy.model_management.cast_to_device(w2b, weight.device, intermediate_dtype)) + m1 = torch.mm(seap.model_management.cast_to_device(w1a, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w1b, weight.device, intermediate_dtype)) + m2 = torch.mm(seap.model_management.cast_to_device(w2a, weight.device, intermediate_dtype), + seap.model_management.cast_to_device(w2b, weight.device, intermediate_dtype)) try: lora_diff = (m1 * m2).reshape(weight.shape) @@ -556,10 +556,10 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32): old_glora = False rank = v[1].shape[0] - a1 = comfy.model_management.cast_to_device(v[0].flatten(start_dim=1), weight.device, intermediate_dtype) - a2 = comfy.model_management.cast_to_device(v[1].flatten(start_dim=1), weight.device, intermediate_dtype) - b1 = comfy.model_management.cast_to_device(v[2].flatten(start_dim=1), weight.device, intermediate_dtype) - b2 = comfy.model_management.cast_to_device(v[3].flatten(start_dim=1), weight.device, intermediate_dtype) + a1 = seap.model_management.cast_to_device(v[0].flatten(start_dim=1), weight.device, intermediate_dtype) + a2 = seap.model_management.cast_to_device(v[1].flatten(start_dim=1), weight.device, intermediate_dtype) + b1 = seap.model_management.cast_to_device(v[2].flatten(start_dim=1), weight.device, intermediate_dtype) + b2 = seap.model_management.cast_to_device(v[3].flatten(start_dim=1), weight.device, intermediate_dtype) if v[4] is not None: alpha = v[4] / rank diff --git a/comfy/model_base.py b/seap/model_base.py similarity index 85% rename from comfy/model_base.py rename to seap/model_base.py index a98fee1d9..5d3f8bd72 100644 --- a/comfy/model_base.py +++ b/seap/model_base.py @@ -18,24 +18,24 @@ import torch import logging -from comfy.ldm.modules.diffusionmodules.openaimodel import UNetModel, Timestep -from comfy.ldm.cascade.stage_c import StageC -from comfy.ldm.cascade.stage_b import StageB -from comfy.ldm.modules.encoders.noise_aug_modules import CLIPEmbeddingNoiseAugmentation -from comfy.ldm.modules.diffusionmodules.upscaling import ImageConcatWithNoiseAugmentation -from comfy.ldm.modules.diffusionmodules.mmdit import OpenAISignatureMMDITWrapper -import comfy.ldm.aura.mmdit -import comfy.ldm.hydit.models -import comfy.ldm.audio.dit -import comfy.ldm.audio.embedders -import comfy.ldm.flux.model +from seap.ldm.modules.diffusionmodules.openaimodel import UNetModel, Timestep +from seap.ldm.cascade.stage_c import StageC +from seap.ldm.cascade.stage_b import StageB +from seap.ldm.modules.encoders.noise_aug_modules import CLIPEmbeddingNoiseAugmentation +from seap.ldm.modules.diffusionmodules.upscaling import ImageConcatWithNoiseAugmentation +from seap.ldm.modules.diffusionmodules.mmdit import OpenAISignatureMMDITWrapper +import seap.ldm.aura.mmdit +import seap.ldm.hydit.models +import seap.ldm.audio.dit +import seap.ldm.audio.embedders +import seap.ldm.flux.model -import comfy.model_management -import comfy.conds -import comfy.ops +import seap.model_management +import seap.conds +import seap.ops from enum import Enum from . import utils -import comfy.latent_formats +import seap.latent_formats import math class ModelType(Enum): @@ -49,7 +49,7 @@ class ModelType(Enum): FLUX = 8 -from comfy.model_sampling import EPS, V_PREDICTION, EDM, ModelSamplingDiscrete, ModelSamplingContinuousEDM, StableCascadeSampling, ModelSamplingContinuousV +from seap.model_sampling import EPS, V_PREDICTION, EDM, ModelSamplingDiscrete, ModelSamplingContinuousEDM, StableCascadeSampling, ModelSamplingContinuousV def model_sampling(model_config, model_type): @@ -63,8 +63,8 @@ def model_sampling(model_config, model_type): c = V_PREDICTION s = ModelSamplingContinuousEDM elif model_type == ModelType.FLOW: - c = comfy.model_sampling.CONST - s = comfy.model_sampling.ModelSamplingDiscreteFlow + c = seap.model_sampling.CONST + s = seap.model_sampling.ModelSamplingDiscreteFlow elif model_type == ModelType.STABLE_CASCADE: c = EPS s = StableCascadeSampling @@ -75,8 +75,8 @@ def model_sampling(model_config, model_type): c = V_PREDICTION s = ModelSamplingContinuousV elif model_type == ModelType.FLUX: - c = comfy.model_sampling.CONST - s = comfy.model_sampling.ModelSamplingFlux + c = seap.model_sampling.CONST + s = seap.model_sampling.ModelSamplingFlux class ModelSampling(s, c): pass @@ -96,11 +96,11 @@ class BaseModel(torch.nn.Module): if not unet_config.get("disable_unet_model_creation", False): if model_config.custom_operations is None: - operations = comfy.ops.pick_operations(unet_config.get("dtype", None), self.manual_cast_dtype, fp8_optimizations=model_config.optimizations.get("fp8", False)) + operations = seap.ops.pick_operations(unet_config.get("dtype", None), self.manual_cast_dtype, fp8_optimizations=model_config.optimizations.get("fp8", False)) else: operations = model_config.custom_operations self.diffusion_model = unet_model(**unet_config, device=device, operations=operations) - if comfy.model_management.force_channels_last(): + if seap.model_management.force_channels_last(): self.diffusion_model.to(memory_format=torch.channels_last) logging.debug("using channels last mode for diffusion model") logging.info("model weight dtype {}, manual cast: {}".format(self.get_dtype(), self.manual_cast_dtype)) @@ -191,23 +191,23 @@ class BaseModel(torch.nn.Module): elif ck == "masked_image": cond_concat.append(self.blank_inpaint_image_like(noise)) data = torch.cat(cond_concat, dim=1) - out['c_concat'] = comfy.conds.CONDNoiseShape(data) + out['c_concat'] = seap.conds.CONDNoiseShape(data) adm = self.encode_adm(**kwargs) if adm is not None: - out['y'] = comfy.conds.CONDRegular(adm) + out['y'] = seap.conds.CONDRegular(adm) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDCrossAttn(cross_attn) + out['c_crossattn'] = seap.conds.CONDCrossAttn(cross_attn) cross_attn_cnet = kwargs.get("cross_attn_controlnet", None) if cross_attn_cnet is not None: - out['crossattn_controlnet'] = comfy.conds.CONDCrossAttn(cross_attn_cnet) + out['crossattn_controlnet'] = seap.conds.CONDCrossAttn(cross_attn_cnet) c_concat = kwargs.get("noise_concat", None) if c_concat is not None: - out['c_concat'] = comfy.conds.CONDNoiseShape(c_concat) + out['c_concat'] = seap.conds.CONDNoiseShape(c_concat) return out @@ -267,13 +267,13 @@ class BaseModel(torch.nn.Module): self.blank_inpaint_image_like = blank_inpaint_image_like def memory_required(self, input_shape): - if comfy.model_management.xformers_enabled() or comfy.model_management.pytorch_attention_flash_attention(): + if seap.model_management.xformers_enabled() or seap.model_management.pytorch_attention_flash_attention(): dtype = self.get_dtype() if self.manual_cast_dtype is not None: dtype = self.manual_cast_dtype #TODO: this needs to be tweaked area = input_shape[0] * math.prod(input_shape[2:]) - return (area * comfy.model_management.dtype_size(dtype) * 0.01 * self.memory_usage_factor) * (1024 * 1024) + return (area * seap.model_management.dtype_size(dtype) * 0.01 * self.memory_usage_factor) * (1024 * 1024) else: #TODO: this formula might be too aggressive since I tweaked the sub-quad and split algorithms to use less memory. area = input_shape[0] * math.prod(input_shape[2:]) @@ -398,7 +398,7 @@ class SVD_img2vid(BaseModel): out = {} adm = self.encode_adm(**kwargs) if adm is not None: - out['y'] = comfy.conds.CONDRegular(adm) + out['y'] = seap.conds.CONDRegular(adm) latent_image = kwargs.get("concat_latent_image", None) noise = kwargs.get("noise", None) @@ -412,16 +412,16 @@ class SVD_img2vid(BaseModel): latent_image = utils.resize_to_batch_size(latent_image, noise.shape[0]) - out['c_concat'] = comfy.conds.CONDNoiseShape(latent_image) + out['c_concat'] = seap.conds.CONDNoiseShape(latent_image) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDCrossAttn(cross_attn) + out['c_crossattn'] = seap.conds.CONDCrossAttn(cross_attn) if "time_conditioning" in kwargs: - out["time_context"] = comfy.conds.CONDCrossAttn(kwargs["time_conditioning"]) + out["time_context"] = seap.conds.CONDCrossAttn(kwargs["time_conditioning"]) - out['num_video_frames'] = comfy.conds.CONDConstant(noise.shape[0]) + out['num_video_frames'] = seap.conds.CONDConstant(noise.shape[0]) return out class SV3D_u(SVD_img2vid): @@ -457,7 +457,7 @@ class SV3D_p(SVD_img2vid): class Stable_Zero123(BaseModel): def __init__(self, model_config, model_type=ModelType.EPS, device=None, cc_projection_weight=None, cc_projection_bias=None): super().__init__(model_config, model_type, device=device) - self.cc_projection = comfy.ops.manual_cast.Linear(cc_projection_weight.shape[1], cc_projection_weight.shape[0], dtype=self.get_dtype(), device=device) + self.cc_projection = seap.ops.manual_cast.Linear(cc_projection_weight.shape[1], cc_projection_weight.shape[0], dtype=self.get_dtype(), device=device) self.cc_projection.weight.copy_(cc_projection_weight) self.cc_projection.bias.copy_(cc_projection_bias) @@ -475,13 +475,13 @@ class Stable_Zero123(BaseModel): latent_image = utils.resize_to_batch_size(latent_image, noise.shape[0]) - out['c_concat'] = comfy.conds.CONDNoiseShape(latent_image) + out['c_concat'] = seap.conds.CONDNoiseShape(latent_image) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: if cross_attn.shape[-1] != 768: cross_attn = self.cc_projection(cross_attn) - out['c_crossattn'] = comfy.conds.CONDCrossAttn(cross_attn) + out['c_crossattn'] = seap.conds.CONDCrossAttn(cross_attn) return out class SD_X4Upscaler(BaseModel): @@ -512,8 +512,8 @@ class SD_X4Upscaler(BaseModel): image = utils.resize_to_batch_size(image, noise.shape[0]) - out['c_concat'] = comfy.conds.CONDNoiseShape(image) - out['y'] = comfy.conds.CONDRegular(noise_level) + out['c_concat'] = seap.conds.CONDNoiseShape(image) + out['y'] = seap.conds.CONDRegular(noise_level) return out class IP2P: @@ -532,10 +532,10 @@ class IP2P: image = utils.resize_to_batch_size(image, noise.shape[0]) - out['c_concat'] = comfy.conds.CONDNoiseShape(self.process_ip2p_image_in(image)) + out['c_concat'] = seap.conds.CONDNoiseShape(self.process_ip2p_image_in(image)) adm = self.encode_adm(**kwargs) if adm is not None: - out['y'] = comfy.conds.CONDRegular(adm) + out['y'] = seap.conds.CONDRegular(adm) return out class SD15_instructpix2pix(IP2P, BaseModel): @@ -547,7 +547,7 @@ class SDXL_instructpix2pix(IP2P, SDXL): def __init__(self, model_config, model_type=ModelType.EPS, device=None): super().__init__(model_config, model_type, device=device) if model_type == ModelType.V_PREDICTION_EDM: - self.process_ip2p_image_in = lambda image: comfy.latent_formats.SDXL().process_in(image) #cosxl ip2p + self.process_ip2p_image_in = lambda image: seap.latent_formats.SDXL().process_in(image) #cosxl ip2p else: self.process_ip2p_image_in = lambda image: image #diffusers ip2p @@ -561,7 +561,7 @@ class StableCascade_C(BaseModel): out = {} clip_text_pooled = kwargs["pooled_output"] if clip_text_pooled is not None: - out['clip_text_pooled'] = comfy.conds.CONDRegular(clip_text_pooled) + out['clip_text_pooled'] = seap.conds.CONDRegular(clip_text_pooled) if "unclip_conditioning" in kwargs: embeds = [] @@ -571,13 +571,13 @@ class StableCascade_C(BaseModel): clip_img = torch.cat(embeds, dim=1) else: clip_img = torch.zeros((1, 1, 768)) - out["clip_img"] = comfy.conds.CONDRegular(clip_img) - out["sca"] = comfy.conds.CONDRegular(torch.zeros((1,))) - out["crp"] = comfy.conds.CONDRegular(torch.zeros((1,))) + out["clip_img"] = seap.conds.CONDRegular(clip_img) + out["sca"] = seap.conds.CONDRegular(torch.zeros((1,))) + out["crp"] = seap.conds.CONDRegular(torch.zeros((1,))) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['clip_text'] = comfy.conds.CONDCrossAttn(cross_attn) + out['clip_text'] = seap.conds.CONDCrossAttn(cross_attn) return out @@ -592,13 +592,13 @@ class StableCascade_B(BaseModel): clip_text_pooled = kwargs["pooled_output"] if clip_text_pooled is not None: - out['clip'] = comfy.conds.CONDRegular(clip_text_pooled) + out['clip'] = seap.conds.CONDRegular(clip_text_pooled) #size of prior doesn't really matter if zeros because it gets resized but I still want it to get batched prior = kwargs.get("stable_cascade_prior", torch.zeros((1, 16, (noise.shape[2] * 4) // 42, (noise.shape[3] * 4) // 42), dtype=noise.dtype, layout=noise.layout, device=noise.device)) - out["effnet"] = comfy.conds.CONDRegular(prior) - out["sca"] = comfy.conds.CONDRegular(torch.zeros((1,))) + out["effnet"] = seap.conds.CONDRegular(prior) + out["sca"] = seap.conds.CONDRegular(torch.zeros((1,))) return out @@ -613,27 +613,27 @@ class SD3(BaseModel): out = super().extra_conds(**kwargs) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) + out['c_crossattn'] = seap.conds.CONDRegular(cross_attn) return out class AuraFlow(BaseModel): def __init__(self, model_config, model_type=ModelType.FLOW, device=None): - super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.aura.mmdit.MMDiT) + super().__init__(model_config, model_type, device=device, unet_model=seap.ldm.aura.mmdit.MMDiT) def extra_conds(self, **kwargs): out = super().extra_conds(**kwargs) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) + out['c_crossattn'] = seap.conds.CONDRegular(cross_attn) return out class StableAudio1(BaseModel): def __init__(self, model_config, seconds_start_embedder_weights, seconds_total_embedder_weights, model_type=ModelType.V_PREDICTION_CONTINUOUS, device=None): - super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.audio.dit.AudioDiffusionTransformer) - self.seconds_start_embedder = comfy.ldm.audio.embedders.NumberConditioner(768, min_val=0, max_val=512) - self.seconds_total_embedder = comfy.ldm.audio.embedders.NumberConditioner(768, min_val=0, max_val=512) + super().__init__(model_config, model_type, device=device, unet_model=seap.ldm.audio.dit.AudioDiffusionTransformer) + self.seconds_start_embedder = seap.ldm.audio.embedders.NumberConditioner(768, min_val=0, max_val=512) + self.seconds_total_embedder = seap.ldm.audio.embedders.NumberConditioner(768, min_val=0, max_val=512) self.seconds_start_embedder.load_state_dict(seconds_start_embedder_weights) self.seconds_total_embedder.load_state_dict(seconds_total_embedder_weights) @@ -650,12 +650,12 @@ class StableAudio1(BaseModel): seconds_total_embed = self.seconds_total_embedder([seconds_total])[0].to(device) global_embed = torch.cat([seconds_start_embed, seconds_total_embed], dim=-1).reshape((1, -1)) - out['global_embed'] = comfy.conds.CONDRegular(global_embed) + out['global_embed'] = seap.conds.CONDRegular(global_embed) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: cross_attn = torch.cat([cross_attn.to(device), seconds_start_embed.repeat((cross_attn.shape[0], 1, 1)), seconds_total_embed.repeat((cross_attn.shape[0], 1, 1))], dim=1) - out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) + out['c_crossattn'] = seap.conds.CONDRegular(cross_attn) return out def state_dict_for_saving(self, clip_state_dict=None, vae_state_dict=None, clip_vision_state_dict=None): @@ -669,25 +669,25 @@ class StableAudio1(BaseModel): class HunyuanDiT(BaseModel): def __init__(self, model_config, model_type=ModelType.V_PREDICTION, device=None): - super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.hydit.models.HunYuanDiT) + super().__init__(model_config, model_type, device=device, unet_model=seap.ldm.hydit.models.HunYuanDiT) def extra_conds(self, **kwargs): out = super().extra_conds(**kwargs) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) + out['c_crossattn'] = seap.conds.CONDRegular(cross_attn) attention_mask = kwargs.get("attention_mask", None) if attention_mask is not None: - out['text_embedding_mask'] = comfy.conds.CONDRegular(attention_mask) + out['text_embedding_mask'] = seap.conds.CONDRegular(attention_mask) conditioning_mt5xl = kwargs.get("conditioning_mt5xl", None) if conditioning_mt5xl is not None: - out['encoder_hidden_states_t5'] = comfy.conds.CONDRegular(conditioning_mt5xl) + out['encoder_hidden_states_t5'] = seap.conds.CONDRegular(conditioning_mt5xl) attention_mask_mt5xl = kwargs.get("attention_mask_mt5xl", None) if attention_mask_mt5xl is not None: - out['text_embedding_mask_t5'] = comfy.conds.CONDRegular(attention_mask_mt5xl) + out['text_embedding_mask_t5'] = seap.conds.CONDRegular(attention_mask_mt5xl) width = kwargs.get("width", 768) height = kwargs.get("height", 768) @@ -696,12 +696,12 @@ class HunyuanDiT(BaseModel): target_width = kwargs.get("target_width", width) target_height = kwargs.get("target_height", height) - out['image_meta_size'] = comfy.conds.CONDRegular(torch.FloatTensor([[height, width, target_height, target_width, 0, 0]])) + out['image_meta_size'] = seap.conds.CONDRegular(torch.FloatTensor([[height, width, target_height, target_width, 0, 0]])) return out class Flux(BaseModel): def __init__(self, model_config, model_type=ModelType.FLUX, device=None): - super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.flux.model.Flux) + super().__init__(model_config, model_type, device=device, unet_model=seap.ldm.flux.model.Flux) def encode_adm(self, **kwargs): return kwargs["pooled_output"] @@ -710,6 +710,6 @@ class Flux(BaseModel): out = super().extra_conds(**kwargs) cross_attn = kwargs.get("cross_attn", None) if cross_attn is not None: - out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn) - out['guidance'] = comfy.conds.CONDRegular(torch.FloatTensor([kwargs.get("guidance", 3.5)])) + out['c_crossattn'] = seap.conds.CONDRegular(cross_attn) + out['guidance'] = seap.conds.CONDRegular(torch.FloatTensor([kwargs.get("guidance", 3.5)])) return out diff --git a/comfy/model_detection.py b/seap/model_detection.py similarity index 97% rename from comfy/model_detection.py rename to seap/model_detection.py index 1edbcda4d..3ffbaca61 100644 --- a/comfy/model_detection.py +++ b/seap/model_detection.py @@ -1,6 +1,6 @@ -import comfy.supported_models -import comfy.supported_models_base -import comfy.utils +import seap.supported_models +import seap.supported_models_base +import seap.utils import math import logging import torch @@ -273,7 +273,7 @@ def detect_unet_config(state_dict, key_prefix): return unet_config def model_config_from_unet_config(unet_config, state_dict=None): - for model_config in comfy.supported_models.models: + for model_config in seap.supported_models.models: if model_config.matches(unet_config, state_dict): return model_config(unet_config) @@ -286,7 +286,7 @@ def model_config_from_unet(state_dict, unet_key_prefix, use_base_if_no_match=Fal return None model_config = model_config_from_unet_config(unet_config, state_dict) if model_config is None and use_base_if_no_match: - return comfy.supported_models_base.BASE(unet_config) + return seap.supported_models_base.BASE(unet_config) else: return model_config @@ -505,15 +505,15 @@ def convert_diffusers_mmdit(state_dict, output_prefix=""): depth = count_blocks(state_dict, 'transformer_blocks.{}.') depth_single_blocks = count_blocks(state_dict, 'single_transformer_blocks.{}.') hidden_size = state_dict["x_embedder.bias"].shape[0] - sd_map = comfy.utils.flux_to_diffusers({"depth": depth, "depth_single_blocks": depth_single_blocks, "hidden_size": hidden_size}, output_prefix=output_prefix) + sd_map = seap.utils.flux_to_diffusers({"depth": depth, "depth_single_blocks": depth_single_blocks, "hidden_size": hidden_size}, output_prefix=output_prefix) elif 'transformer_blocks.0.attn.add_q_proj.weight' in state_dict: #SD3 num_blocks = count_blocks(state_dict, 'transformer_blocks.{}.') depth = state_dict["pos_embed.proj.weight"].shape[0] // 64 - sd_map = comfy.utils.mmdit_to_diffusers({"depth": depth, "num_blocks": num_blocks}, output_prefix=output_prefix) + sd_map = seap.utils.mmdit_to_diffusers({"depth": depth, "num_blocks": num_blocks}, output_prefix=output_prefix) elif 'joint_transformer_blocks.0.attn.add_k_proj.weight' in state_dict: #AuraFlow num_joint = count_blocks(state_dict, 'joint_transformer_blocks.{}.') num_single = count_blocks(state_dict, 'single_transformer_blocks.{}.') - sd_map = comfy.utils.auraflow_to_diffusers({"n_double_layers": num_joint, "n_layers": num_joint + num_single}, output_prefix=output_prefix) + sd_map = seap.utils.auraflow_to_diffusers({"n_double_layers": num_joint, "n_layers": num_joint + num_single}, output_prefix=output_prefix) else: return None diff --git a/comfy/model_management.py b/seap/model_management.py similarity index 99% rename from comfy/model_management.py rename to seap/model_management.py index 2346d4acb..de92068f9 100644 --- a/comfy/model_management.py +++ b/seap/model_management.py @@ -19,7 +19,7 @@ import psutil import logging from enum import Enum -from comfy.cli_args import args +from seap.cli_args import args import torch import sys import platform @@ -1101,7 +1101,7 @@ def unload_all_models(): def resolve_lowvram_weight(weight, model, key): #TODO: remove - print("WARNING: The comfy.model_management.resolve_lowvram_weight function will be removed soon, please stop using it.") + print("WARNING: The seap.model_management.resolve_lowvram_weight function will be removed soon, please stop using it.") return weight #TODO: might be cleaner to put this somewhere else diff --git a/comfy/model_patcher.py b/seap/model_patcher.py similarity index 91% rename from comfy/model_patcher.py rename to seap/model_patcher.py index 2ba306335..8fd47b3ca 100644 --- a/comfy/model_patcher.py +++ b/seap/model_patcher.py @@ -24,11 +24,11 @@ import uuid import collections import math -import comfy.utils -import comfy.float -import comfy.model_management -import comfy.lora -from comfy.comfy_types import UnetWrapperFunction +import seap.utils +import seap.float +import seap.model_management +import seap.lora +from seap.comfy_types import UnetWrapperFunction def string_to_seed(data): crc = 0xFFFFFFFF @@ -91,9 +91,9 @@ class LowVramPatch: intermediate_dtype = weight.dtype if intermediate_dtype not in [torch.float32, torch.float16, torch.bfloat16]: #intermediate_dtype has to be one that is supported in math ops intermediate_dtype = torch.float32 - return comfy.float.stochastic_rounding(comfy.lora.calculate_weight(self.patches[self.key], weight.to(intermediate_dtype), self.key, intermediate_dtype=intermediate_dtype), weight.dtype, seed=string_to_seed(self.key)) + return seap.float.stochastic_rounding(seap.lora.calculate_weight(self.patches[self.key], weight.to(intermediate_dtype), self.key, intermediate_dtype=intermediate_dtype), weight.dtype, seed=string_to_seed(self.key)) - return comfy.lora.calculate_weight(self.patches[self.key], weight, self.key, intermediate_dtype=intermediate_dtype) + return seap.lora.calculate_weight(self.patches[self.key], weight, self.key, intermediate_dtype=intermediate_dtype) class ModelPatcher: def __init__(self, model, load_device, offload_device, size=0, weight_inplace_update=False): self.size = size @@ -127,7 +127,7 @@ class ModelPatcher: def model_size(self): if self.size > 0: return self.size - self.size = comfy.model_management.module_size(self.model) + self.size = seap.model_management.module_size(self.model) return self.size def loaded_size(self): @@ -236,7 +236,7 @@ class ModelPatcher: if name in self.object_patches_backup: return self.object_patches_backup[name] else: - return comfy.utils.get_attr(self.model, name) + return seap.utils.get_attr(self.model, name) def model_patches_to(self, device): to = self.model_options["transformer_options"] @@ -317,7 +317,7 @@ class ModelPatcher: if key not in self.patches: return - weight = comfy.utils.get_attr(self.model, key) + weight = seap.utils.get_attr(self.model, key) inplace_update = self.weight_inplace_update or inplace_update @@ -325,15 +325,15 @@ class ModelPatcher: self.backup[key] = collections.namedtuple('Dimension', ['weight', 'inplace_update'])(weight.to(device=self.offload_device, copy=inplace_update), inplace_update) if device_to is not None: - temp_weight = comfy.model_management.cast_to_device(weight, device_to, torch.float32, copy=True) + temp_weight = seap.model_management.cast_to_device(weight, device_to, torch.float32, copy=True) else: temp_weight = weight.to(torch.float32, copy=True) - out_weight = comfy.lora.calculate_weight(self.patches[key], temp_weight, key) - out_weight = comfy.float.stochastic_rounding(out_weight, weight.dtype, seed=string_to_seed(key)) + out_weight = seap.lora.calculate_weight(self.patches[key], temp_weight, key) + out_weight = seap.float.stochastic_rounding(out_weight, weight.dtype, seed=string_to_seed(key)) if inplace_update: - comfy.utils.copy_to_param(self.model, key, out_weight) + seap.utils.copy_to_param(self.model, key, out_weight) else: - comfy.utils.set_attr_param(self.model, key, out_weight) + seap.utils.set_attr_param(self.model, key, out_weight) def load(self, device_to=None, lowvram_model_memory=0, force_patch_weights=False, full_load=False): mem_counter = 0 @@ -342,7 +342,7 @@ class ModelPatcher: loading = [] for n, m in self.model.named_modules(): if hasattr(m, "comfy_cast_weights") or hasattr(m, "weight"): - loading.append((comfy.model_management.module_size(m), n, m)) + loading.append((seap.model_management.module_size(m), n, m)) load_completely = [] loading.sort(reverse=True) @@ -422,7 +422,7 @@ class ModelPatcher: def patch_model(self, device_to=None, lowvram_model_memory=0, load_weights=True, force_patch_weights=False): for k in self.object_patches: - old = comfy.utils.set_attr(self.model, k, self.object_patches[k]) + old = seap.utils.set_attr(self.model, k, self.object_patches[k]) if k not in self.object_patches_backup: self.object_patches_backup[k] = old @@ -449,9 +449,9 @@ class ModelPatcher: for k in keys: bk = self.backup[k] if bk.inplace_update: - comfy.utils.copy_to_param(self.model, k, bk.weight) + seap.utils.copy_to_param(self.model, k, bk.weight) else: - comfy.utils.set_attr_param(self.model, k, bk.weight) + seap.utils.set_attr_param(self.model, k, bk.weight) self.backup.clear() @@ -466,7 +466,7 @@ class ModelPatcher: keys = list(self.object_patches_backup.keys()) for k in keys: - comfy.utils.set_attr(self.model, k, self.object_patches_backup[k]) + seap.utils.set_attr(self.model, k, self.object_patches_backup[k]) self.object_patches_backup.clear() @@ -478,7 +478,7 @@ class ModelPatcher: for n, m in self.model.named_modules(): shift_lowvram = False if hasattr(m, "comfy_cast_weights"): - module_mem = comfy.model_management.module_size(m) + module_mem = seap.model_management.module_size(m) unload_list.append((module_mem, n, m)) unload_list.sort() @@ -496,9 +496,9 @@ class ModelPatcher: bk = self.backup.get(key, None) if bk is not None: if bk.inplace_update: - comfy.utils.copy_to_param(self.model, key, bk.weight) + seap.utils.copy_to_param(self.model, key, bk.weight) else: - comfy.utils.set_attr_param(self.model, key, bk.weight) + seap.utils.set_attr_param(self.model, key, bk.weight) self.backup.pop(key) m.to(device_to) @@ -536,5 +536,5 @@ class ModelPatcher: return self.model.device def calculate_weight(self, patches, weight, key, intermediate_dtype=torch.float32): - print("WARNING the ModelPatcher.calculate_weight function is deprecated, please use: comfy.lora.calculate_weight instead") - return comfy.lora.calculate_weight(patches, weight, key, intermediate_dtype=intermediate_dtype) + print("WARNING the ModelPatcher.calculate_weight function is deprecated, please use: seap.lora.calculate_weight instead") + return seap.lora.calculate_weight(patches, weight, key, intermediate_dtype=intermediate_dtype) diff --git a/comfy/model_sampling.py b/seap/model_sampling.py similarity index 99% rename from comfy/model_sampling.py rename to seap/model_sampling.py index 4a0f2db60..3bf24c58a 100644 --- a/comfy/model_sampling.py +++ b/seap/model_sampling.py @@ -1,5 +1,5 @@ import torch -from comfy.ldm.modules.diffusionmodules.util import make_beta_schedule +from seap.ldm.modules.diffusionmodules.util import make_beta_schedule import math class EPS: diff --git a/comfy/ops.py b/seap/ops.py similarity index 97% rename from comfy/ops.py rename to seap/ops.py index c90e25ead..2b27a3c9e 100644 --- a/comfy/ops.py +++ b/seap/ops.py @@ -17,8 +17,8 @@ """ import torch -import comfy.model_management -from comfy.cli_args import args +import seap.model_management +from seap.cli_args import args def cast_to(weight, dtype=None, device=None, non_blocking=False, copy=False): if device is None or weight.device == device: @@ -44,7 +44,7 @@ def cast_bias_weight(s, input=None, dtype=None, device=None, bias_dtype=None): device = input.device bias = None - non_blocking = comfy.model_management.device_supports_non_blocking(device) + non_blocking = seap.model_management.device_supports_non_blocking(device) if s.bias is not None: has_function = s.bias_function is not None bias = cast_to(s.bias, bias_dtype, device, non_blocking=non_blocking, copy=has_function) @@ -300,13 +300,13 @@ class fp8_ops(manual_cast): def pick_operations(weight_dtype, compute_dtype, load_device=None, disable_fast_fp8=False, fp8_optimizations=False): - if comfy.model_management.supports_fp8_compute(load_device): + if seap.model_management.supports_fp8_compute(load_device): if (fp8_optimizations or args.fast) and not disable_fast_fp8: return fp8_ops if compute_dtype is None or weight_dtype == compute_dtype: return disable_weight_init if args.fast and not disable_fast_fp8: - if comfy.model_management.supports_fp8_compute(load_device): + if seap.model_management.supports_fp8_compute(load_device): return fp8_ops return manual_cast diff --git a/comfy/options.py b/seap/options.py similarity index 100% rename from comfy/options.py rename to seap/options.py diff --git a/comfy/sample.py b/seap/sample.py similarity index 69% rename from comfy/sample.py rename to seap/sample.py index 98dcaca7f..d7e39d653 100644 --- a/comfy/sample.py +++ b/seap/sample.py @@ -1,7 +1,7 @@ import torch -import comfy.model_management -import comfy.samplers -import comfy.utils +import seap.model_management +import seap.samplers +import seap.utils import numpy as np import logging @@ -27,24 +27,24 @@ def prepare_noise(latent_image, seed, noise_inds=None): def fix_empty_latent_channels(model, latent_image): latent_channels = model.get_model_object("latent_format").latent_channels #Resize the empty latent image so it has the right number of channels if latent_channels != latent_image.shape[1] and torch.count_nonzero(latent_image) == 0: - latent_image = comfy.utils.repeat_to_batch_size(latent_image, latent_channels, dim=1) + latent_image = seap.utils.repeat_to_batch_size(latent_image, latent_channels, dim=1) return latent_image def prepare_sampling(model, noise_shape, positive, negative, noise_mask): - logging.warning("Warning: comfy.sample.prepare_sampling isn't used anymore and can be removed") + logging.warning("Warning: seap.sample.prepare_sampling isn't used anymore and can be removed") return model, positive, negative, noise_mask, [] def cleanup_additional_models(models): - logging.warning("Warning: comfy.sample.cleanup_additional_models isn't used anymore and can be removed") + logging.warning("Warning: seap.sample.cleanup_additional_models isn't used anymore and can be removed") def sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=1.0, disable_noise=False, start_step=None, last_step=None, force_full_denoise=False, noise_mask=None, sigmas=None, callback=None, disable_pbar=False, seed=None): - sampler = comfy.samplers.KSampler(model, steps=steps, device=model.load_device, sampler=sampler_name, scheduler=scheduler, denoise=denoise, model_options=model.model_options) + sampler = seap.samplers.KSampler(model, steps=steps, device=model.load_device, sampler=sampler_name, scheduler=scheduler, denoise=denoise, model_options=model.model_options) samples = sampler.sample(noise, positive, negative, cfg=cfg, latent_image=latent_image, start_step=start_step, last_step=last_step, force_full_denoise=force_full_denoise, denoise_mask=noise_mask, sigmas=sigmas, callback=callback, disable_pbar=disable_pbar, seed=seed) - samples = samples.to(comfy.model_management.intermediate_device()) + samples = samples.to(seap.model_management.intermediate_device()) return samples def sample_custom(model, noise, cfg, sampler, sigmas, positive, negative, latent_image, noise_mask=None, callback=None, disable_pbar=False, seed=None): - samples = comfy.samplers.sample(model, noise, positive, negative, cfg, model.load_device, sampler, sigmas, model_options=model.model_options, latent_image=latent_image, denoise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed) - samples = samples.to(comfy.model_management.intermediate_device()) + samples = seap.samplers.sample(model, noise, positive, negative, cfg, model.load_device, sampler, sigmas, model_options=model.model_options, latent_image=latent_image, denoise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=seed) + samples = samples.to(seap.model_management.intermediate_device()) return samples diff --git a/comfy/sampler_helpers.py b/seap/sampler_helpers.py similarity index 86% rename from comfy/sampler_helpers.py rename to seap/sampler_helpers.py index 4a2ec123b..711211548 100644 --- a/comfy/sampler_helpers.py +++ b/seap/sampler_helpers.py @@ -1,12 +1,12 @@ import torch -import comfy.model_management -import comfy.conds +import seap.model_management +import seap.conds def prepare_mask(noise_mask, shape, device): """ensures noise mask is of proper dimensions""" noise_mask = torch.nn.functional.interpolate(noise_mask.reshape((-1, 1, noise_mask.shape[-2], noise_mask.shape[-1])), size=(shape[2], shape[3]), mode="bilinear") noise_mask = torch.cat([noise_mask] * shape[1], dim=1) - noise_mask = comfy.utils.repeat_to_batch_size(noise_mask, shape[0]) + noise_mask = seap.utils.repeat_to_batch_size(noise_mask, shape[0]) noise_mask = noise_mask.to(device) return noise_mask @@ -23,7 +23,7 @@ def convert_cond(cond): temp = c[1].copy() model_conds = temp.get("model_conds", {}) if c[0] is not None: - model_conds["c_crossattn"] = comfy.conds.CONDCrossAttn(c[0]) #TODO: remove + model_conds["c_crossattn"] = seap.conds.CONDCrossAttn(c[0]) #TODO: remove temp["cross_attn"] = c[0] temp["model_conds"] = model_conds out.append(temp) @@ -63,7 +63,7 @@ def prepare_sampling(model, noise_shape, conds): models, inference_memory = get_additional_models(conds, model.model_dtype()) memory_required = model.memory_required([noise_shape[0] * 2] + list(noise_shape[1:])) + inference_memory minimum_memory_required = model.memory_required([noise_shape[0]] + list(noise_shape[1:])) + inference_memory - comfy.model_management.load_models_gpu([model] + models, memory_required=memory_required, minimum_memory_required=minimum_memory_required) + seap.model_management.load_models_gpu([model] + models, memory_required=memory_required, minimum_memory_required=minimum_memory_required) real_model = model.model return real_model, conds, models diff --git a/comfy/samplers.py b/seap/samplers.py similarity index 97% rename from comfy/samplers.py rename to seap/samplers.py index 1ecb41dda..343f39de9 100644 --- a/comfy/samplers.py +++ b/seap/samplers.py @@ -2,10 +2,10 @@ from .k_diffusion import sampling as k_diffusion_sampling from .extra_samplers import uni_pc import torch import collections -from comfy import model_management +from seap import model_management import math import logging -import comfy.sampler_helpers +import seap.sampler_helpers import scipy.stats import numpy @@ -249,7 +249,7 @@ def calc_cond_batch(model, conds, x_in, timestep, model_options): return out_conds def calc_cond_uncond_batch(model, cond, uncond, x_in, timestep, model_options): #TODO: remove - logging.warning("WARNING: The comfy.samplers.calc_cond_uncond_batch function is deprecated please use the calc_cond_batch one instead.") + logging.warning("WARNING: The seap.samplers.calc_cond_uncond_batch function is deprecated please use the calc_cond_batch one instead.") return tuple(calc_cond_batch(model, [cond, uncond], x_in, timestep, model_options)) def cfg_function(model, cond_pred, uncond_pred, cond_scale, x, timestep, model_options={}, cond=None, uncond=None): @@ -434,7 +434,7 @@ def resolve_areas_and_cond_masks_multidim(conditions, dims, device): conditions[i] = modified def resolve_areas_and_cond_masks(conditions, h, w, device): - logging.warning("WARNING: The comfy.samplers.resolve_areas_and_cond_masks function is deprecated please use the resolve_areas_and_cond_masks_multidim one instead.") + logging.warning("WARNING: The seap.samplers.resolve_areas_and_cond_masks function is deprecated please use the resolve_areas_and_cond_masks_multidim one instead.") return resolve_areas_and_cond_masks_multidim(conditions, [h, w], device) def create_cond_with_same_area_if_none(conds, c): #TODO: handle dim != 2 @@ -676,7 +676,7 @@ class CFGGuider: def inner_set_conds(self, conds): for k in conds: - self.original_conds[k] = comfy.sampler_helpers.convert_cond(conds[k]) + self.original_conds[k] = seap.sampler_helpers.convert_cond(conds[k]) def __call__(self, *args, **kwargs): return self.predict_noise(*args, **kwargs) @@ -703,11 +703,11 @@ class CFGGuider: for k in self.original_conds: self.conds[k] = list(map(lambda a: a.copy(), self.original_conds[k])) - self.inner_model, self.conds, self.loaded_models = comfy.sampler_helpers.prepare_sampling(self.model_patcher, noise.shape, self.conds) + self.inner_model, self.conds, self.loaded_models = seap.sampler_helpers.prepare_sampling(self.model_patcher, noise.shape, self.conds) device = self.model_patcher.load_device if denoise_mask is not None: - denoise_mask = comfy.sampler_helpers.prepare_mask(denoise_mask, noise.shape, device) + denoise_mask = seap.sampler_helpers.prepare_mask(denoise_mask, noise.shape, device) noise = noise.to(device) latent_image = latent_image.to(device) @@ -715,7 +715,7 @@ class CFGGuider: output = self.inner_sample(noise, latent_image, device, sampler, sigmas, denoise_mask, callback, disable_pbar, seed) - comfy.sampler_helpers.cleanup_models(self.conds, self.loaded_models) + seap.sampler_helpers.cleanup_models(self.conds, self.loaded_models) del self.inner_model del self.conds del self.loaded_models diff --git a/comfy/sd.py b/seap/sd.py similarity index 79% rename from comfy/sd.py rename to seap/sd.py index 67b4ff0cf..3d5415c00 100644 --- a/comfy/sd.py +++ b/seap/sd.py @@ -2,14 +2,14 @@ import torch from enum import Enum import logging -from comfy import model_management +from seap import model_management from .ldm.models.autoencoder import AutoencoderKL, AutoencodingEngine from .ldm.cascade.stage_a import StageA from .ldm.cascade.stage_c_coder import StageC_coder from .ldm.audio.autoencoder import AudioOobleckVAE import yaml -import comfy.utils +import seap.utils from . import clip_vision from . import gligen @@ -18,27 +18,27 @@ from . import model_detection from . import sd1_clip from . import sdxl_clip -import comfy.text_encoders.sd2_clip -import comfy.text_encoders.sd3_clip -import comfy.text_encoders.sa_t5 -import comfy.text_encoders.aura_t5 -import comfy.text_encoders.hydit -import comfy.text_encoders.flux -import comfy.text_encoders.long_clipl +import seap.text_encoders.sd2_clip +import seap.text_encoders.sd3_clip +import seap.text_encoders.sa_t5 +import seap.text_encoders.aura_t5 +import seap.text_encoders.hydit +import seap.text_encoders.flux +import seap.text_encoders.long_clipl -import comfy.model_patcher -import comfy.lora -import comfy.t2i_adapter.adapter -import comfy.taesd.taesd +import seap.model_patcher +import seap.lora +import seap.t2i_adapter.adapter +import seap.taesd.taesd def load_lora_for_models(model, clip, lora, strength_model, strength_clip): key_map = {} if model is not None: - key_map = comfy.lora.model_lora_keys_unet(model.model, key_map) + key_map = seap.lora.model_lora_keys_unet(model.model, key_map) if clip is not None: - key_map = comfy.lora.model_lora_keys_clip(clip.cond_stage_model, key_map) + key_map = seap.lora.model_lora_keys_clip(clip.cond_stage_model, key_map) - loaded = comfy.lora.load_lora(lora, key_map) + loaded = seap.lora.load_lora(lora, key_map) if model is not None: new_modelpatcher = model.clone() k = new_modelpatcher.add_patches(loaded, strength_model) @@ -89,7 +89,7 @@ class CLIP: logging.warning("Had to shift TE back.") self.tokenizer = tokenizer(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data) - self.patcher = comfy.model_patcher.ModelPatcher(self.cond_stage_model, load_device=load_device, offload_device=offload_device) + self.patcher = seap.model_patcher.ModelPatcher(self.cond_stage_model, load_device=load_device, offload_device=offload_device) if params['device'] == load_device: model_management.load_models_gpu([self.patcher], force_full_load=True) self.layer_idx = None @@ -180,12 +180,12 @@ class VAE: decoder_config = encoder_config.copy() decoder_config["video_kernel_size"] = [3, 1, 1] decoder_config["alpha"] = 0.0 - self.first_stage_model = AutoencodingEngine(regularizer_config={'target': "comfy.ldm.models.autoencoder.DiagonalGaussianRegularizer"}, - encoder_config={'target': "comfy.ldm.modules.diffusionmodules.model.Encoder", 'params': encoder_config}, - decoder_config={'target': "comfy.ldm.modules.temporal_ae.VideoDecoder", 'params': decoder_config}) + self.first_stage_model = AutoencodingEngine(regularizer_config={'target': "seap.ldm.models.autoencoder.DiagonalGaussianRegularizer"}, + encoder_config={'target': "seap.ldm.modules.diffusionmodules.model.Encoder", 'params': encoder_config}, + decoder_config={'target': "seap.ldm.modules.temporal_ae.VideoDecoder", 'params': decoder_config}) elif "taesd_decoder.1.weight" in sd: self.latent_channels = sd["taesd_decoder.1.weight"].shape[1] - self.first_stage_model = comfy.taesd.taesd.TAESD(latent_channels=self.latent_channels) + self.first_stage_model = seap.taesd.taesd.TAESD(latent_channels=self.latent_channels) elif "vquantizer.codebook.weight" in sd: #VQGan: stage a of stable cascade self.first_stage_model = StageA() self.downscale_ratio = 4 @@ -227,9 +227,9 @@ class VAE: if 'quant_conv.weight' in sd: self.first_stage_model = AutoencoderKL(ddconfig=ddconfig, embed_dim=4) else: - self.first_stage_model = AutoencodingEngine(regularizer_config={'target': "comfy.ldm.models.autoencoder.DiagonalGaussianRegularizer"}, - encoder_config={'target': "comfy.ldm.modules.diffusionmodules.model.Encoder", 'params': ddconfig}, - decoder_config={'target': "comfy.ldm.modules.diffusionmodules.model.Decoder", 'params': ddconfig}) + self.first_stage_model = AutoencodingEngine(regularizer_config={'target': "seap.ldm.models.autoencoder.DiagonalGaussianRegularizer"}, + encoder_config={'target': "seap.ldm.modules.diffusionmodules.model.Encoder", 'params': ddconfig}, + decoder_config={'target': "seap.ldm.modules.diffusionmodules.model.Decoder", 'params': ddconfig}) elif "decoder.layers.1.layers.0.beta" in sd: self.first_stage_model = AudioOobleckVAE() self.memory_used_encode = lambda shape, dtype: (1000 * shape[2]) * model_management.dtype_size(dtype) @@ -266,7 +266,7 @@ class VAE: self.first_stage_model.to(self.vae_dtype) self.output_device = model_management.intermediate_device() - self.patcher = comfy.model_patcher.ModelPatcher(self.first_stage_model, load_device=self.device, offload_device=offload_device) + self.patcher = seap.model_patcher.ModelPatcher(self.first_stage_model, load_device=self.device, offload_device=offload_device) logging.debug("VAE load device: {}, offload device: {}, dtype: {}".format(self.device, offload_device, self.vae_dtype)) def vae_encode_crop_pixels(self, pixels): @@ -279,39 +279,39 @@ class VAE: return pixels def decode_tiled_(self, samples, tile_x=64, tile_y=64, overlap = 16): - steps = samples.shape[0] * comfy.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x, tile_y, overlap) - steps += samples.shape[0] * comfy.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x // 2, tile_y * 2, overlap) - steps += samples.shape[0] * comfy.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x * 2, tile_y // 2, overlap) - pbar = comfy.utils.ProgressBar(steps) + steps = samples.shape[0] * seap.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x, tile_y, overlap) + steps += samples.shape[0] * seap.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x // 2, tile_y * 2, overlap) + steps += samples.shape[0] * seap.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x * 2, tile_y // 2, overlap) + pbar = seap.utils.ProgressBar(steps) decode_fn = lambda a: self.first_stage_model.decode(a.to(self.vae_dtype).to(self.device)).float() output = self.process_output( - (comfy.utils.tiled_scale(samples, decode_fn, tile_x // 2, tile_y * 2, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar) + - comfy.utils.tiled_scale(samples, decode_fn, tile_x * 2, tile_y // 2, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar) + - comfy.utils.tiled_scale(samples, decode_fn, tile_x, tile_y, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar)) + (seap.utils.tiled_scale(samples, decode_fn, tile_x // 2, tile_y * 2, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar) + + seap.utils.tiled_scale(samples, decode_fn, tile_x * 2, tile_y // 2, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar) + + seap.utils.tiled_scale(samples, decode_fn, tile_x, tile_y, overlap, upscale_amount = self.upscale_ratio, output_device=self.output_device, pbar = pbar)) / 3.0) return output def decode_tiled_1d(self, samples, tile_x=128, overlap=32): decode_fn = lambda a: self.first_stage_model.decode(a.to(self.vae_dtype).to(self.device)).float() - return comfy.utils.tiled_scale_multidim(samples, decode_fn, tile=(tile_x,), overlap=overlap, upscale_amount=self.upscale_ratio, out_channels=self.output_channels, output_device=self.output_device) + return seap.utils.tiled_scale_multidim(samples, decode_fn, tile=(tile_x,), overlap=overlap, upscale_amount=self.upscale_ratio, out_channels=self.output_channels, output_device=self.output_device) def encode_tiled_(self, pixel_samples, tile_x=512, tile_y=512, overlap = 64): - steps = pixel_samples.shape[0] * comfy.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x, tile_y, overlap) - steps += pixel_samples.shape[0] * comfy.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x // 2, tile_y * 2, overlap) - steps += pixel_samples.shape[0] * comfy.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x * 2, tile_y // 2, overlap) - pbar = comfy.utils.ProgressBar(steps) + steps = pixel_samples.shape[0] * seap.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x, tile_y, overlap) + steps += pixel_samples.shape[0] * seap.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x // 2, tile_y * 2, overlap) + steps += pixel_samples.shape[0] * seap.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x * 2, tile_y // 2, overlap) + pbar = seap.utils.ProgressBar(steps) encode_fn = lambda a: self.first_stage_model.encode((self.process_input(a)).to(self.vae_dtype).to(self.device)).float() - samples = comfy.utils.tiled_scale(pixel_samples, encode_fn, tile_x, tile_y, overlap, upscale_amount = (1/self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) - samples += comfy.utils.tiled_scale(pixel_samples, encode_fn, tile_x * 2, tile_y // 2, overlap, upscale_amount = (1/self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) - samples += comfy.utils.tiled_scale(pixel_samples, encode_fn, tile_x // 2, tile_y * 2, overlap, upscale_amount = (1/self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) + samples = seap.utils.tiled_scale(pixel_samples, encode_fn, tile_x, tile_y, overlap, upscale_amount = (1 / self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) + samples += seap.utils.tiled_scale(pixel_samples, encode_fn, tile_x * 2, tile_y // 2, overlap, upscale_amount = (1 / self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) + samples += seap.utils.tiled_scale(pixel_samples, encode_fn, tile_x // 2, tile_y * 2, overlap, upscale_amount = (1 / self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device, pbar=pbar) samples /= 3.0 return samples def encode_tiled_1d(self, samples, tile_x=128 * 2048, overlap=32 * 2048): encode_fn = lambda a: self.first_stage_model.encode((self.process_input(a)).to(self.vae_dtype).to(self.device)).float() - return comfy.utils.tiled_scale_multidim(samples, encode_fn, tile=(tile_x,), overlap=overlap, upscale_amount=(1/self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device) + return seap.utils.tiled_scale_multidim(samples, encode_fn, tile=(tile_x,), overlap=overlap, upscale_amount=(1 / self.downscale_ratio), out_channels=self.latent_channels, output_device=self.output_device) def decode(self, samples_in): try: @@ -382,10 +382,10 @@ class StyleModel: def load_style_model(ckpt_path): - model_data = comfy.utils.load_torch_file(ckpt_path, safe_load=True) + model_data = seap.utils.load_torch_file(ckpt_path, safe_load=True) keys = model_data.keys() if "style_embedding" in keys: - model = comfy.t2i_adapter.adapter.StyleAdapter(width=1024, context_dim=768, num_head=8, n_layes=3, num_token=8) + model = seap.t2i_adapter.adapter.StyleAdapter(width=1024, context_dim=768, num_head=8, n_layes=3, num_token=8) else: raise Exception("invalid style model {}".format(ckpt_path)) model.load_state_dict(model_data) @@ -402,7 +402,7 @@ class CLIPType(Enum): def load_clip(ckpt_paths, embedding_directory=None, clip_type=CLIPType.STABLE_DIFFUSION, model_options={}): clip_data = [] for p in ckpt_paths: - clip_data.append(comfy.utils.load_torch_file(p, safe_load=True)) + clip_data.append(seap.utils.load_torch_file(p, safe_load=True)) return load_text_encoder_state_dicts(clip_data, embedding_directory=embedding_directory, clip_type=clip_type, model_options=model_options) @@ -452,7 +452,7 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip for i in range(len(clip_data)): if "transformer.resblocks.0.ln_1.weight" in clip_data[i]: - clip_data[i] = comfy.utils.clip_text_transformers_convert(clip_data[i], "", "") + clip_data[i] = seap.utils.clip_text_transformers_convert(clip_data[i], "", "") else: if "text_projection" in clip_data[i]: clip_data[i]["text_projection.weight"] = clip_data[i]["text_projection"].transpose(0, 1) #old models saved with the CLIPSave node @@ -466,53 +466,53 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip clip_target.clip = sdxl_clip.StableCascadeClipModel clip_target.tokenizer = sdxl_clip.StableCascadeTokenizer elif clip_type == CLIPType.SD3: - clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=True, t5=False) - clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer + clip_target.clip = seap.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=True, t5=False) + clip_target.tokenizer = seap.text_encoders.sd3_clip.SD3Tokenizer else: clip_target.clip = sdxl_clip.SDXLRefinerClipModel clip_target.tokenizer = sdxl_clip.SDXLTokenizer elif te_model == TEModel.CLIP_H: - clip_target.clip = comfy.text_encoders.sd2_clip.SD2ClipModel - clip_target.tokenizer = comfy.text_encoders.sd2_clip.SD2Tokenizer + clip_target.clip = seap.text_encoders.sd2_clip.SD2ClipModel + clip_target.tokenizer = seap.text_encoders.sd2_clip.SD2Tokenizer elif te_model == TEModel.T5_XXL: - clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=t5xxl_weight_dtype(clip_data)) - clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer + clip_target.clip = seap.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=t5xxl_weight_dtype(clip_data)) + clip_target.tokenizer = seap.text_encoders.sd3_clip.SD3Tokenizer elif te_model == TEModel.T5_XL: - clip_target.clip = comfy.text_encoders.aura_t5.AuraT5Model - clip_target.tokenizer = comfy.text_encoders.aura_t5.AuraT5Tokenizer + clip_target.clip = seap.text_encoders.aura_t5.AuraT5Model + clip_target.tokenizer = seap.text_encoders.aura_t5.AuraT5Tokenizer elif te_model == TEModel.T5_BASE: - clip_target.clip = comfy.text_encoders.sa_t5.SAT5Model - clip_target.tokenizer = comfy.text_encoders.sa_t5.SAT5Tokenizer + clip_target.clip = seap.text_encoders.sa_t5.SAT5Model + clip_target.tokenizer = seap.text_encoders.sa_t5.SAT5Tokenizer else: if clip_type == CLIPType.SD3: - clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=True, clip_g=False, t5=False) - clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer + clip_target.clip = seap.text_encoders.sd3_clip.sd3_clip(clip_l=True, clip_g=False, t5=False) + clip_target.tokenizer = seap.text_encoders.sd3_clip.SD3Tokenizer else: clip_target.clip = sd1_clip.SD1ClipModel clip_target.tokenizer = sd1_clip.SD1Tokenizer elif len(clip_data) == 2: if clip_type == CLIPType.SD3: te_models = [detect_te_model(clip_data[0]), detect_te_model(clip_data[1])] - clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=TEModel.CLIP_L in te_models, clip_g=TEModel.CLIP_G in te_models, t5=TEModel.T5_XXL in te_models, dtype_t5=t5xxl_weight_dtype(clip_data)) - clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer + clip_target.clip = seap.text_encoders.sd3_clip.sd3_clip(clip_l=TEModel.CLIP_L in te_models, clip_g=TEModel.CLIP_G in te_models, t5=TEModel.T5_XXL in te_models, dtype_t5=t5xxl_weight_dtype(clip_data)) + clip_target.tokenizer = seap.text_encoders.sd3_clip.SD3Tokenizer elif clip_type == CLIPType.HUNYUAN_DIT: - clip_target.clip = comfy.text_encoders.hydit.HyditModel - clip_target.tokenizer = comfy.text_encoders.hydit.HyditTokenizer + clip_target.clip = seap.text_encoders.hydit.HyditModel + clip_target.tokenizer = seap.text_encoders.hydit.HyditTokenizer elif clip_type == CLIPType.FLUX: - clip_target.clip = comfy.text_encoders.flux.flux_clip(dtype_t5=t5xxl_weight_dtype(clip_data)) - clip_target.tokenizer = comfy.text_encoders.flux.FluxTokenizer + clip_target.clip = seap.text_encoders.flux.flux_clip(dtype_t5=t5xxl_weight_dtype(clip_data)) + clip_target.tokenizer = seap.text_encoders.flux.FluxTokenizer else: clip_target.clip = sdxl_clip.SDXLClipModel clip_target.tokenizer = sdxl_clip.SDXLTokenizer elif len(clip_data) == 3: - clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(dtype_t5=t5xxl_weight_dtype(clip_data)) - clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer + clip_target.clip = seap.text_encoders.sd3_clip.sd3_clip(dtype_t5=t5xxl_weight_dtype(clip_data)) + clip_target.tokenizer = seap.text_encoders.sd3_clip.SD3Tokenizer parameters = 0 tokenizer_data = {} for c in clip_data: - parameters += comfy.utils.calculate_parameters(c) - tokenizer_data, model_options = comfy.text_encoders.long_clipl.model_options_long_clip(c, tokenizer_data, model_options) + parameters += seap.utils.calculate_parameters(c) + tokenizer_data, model_options = seap.text_encoders.long_clipl.model_options_long_clip(c, tokenizer_data, model_options) clip = CLIP(clip_target, embedding_directory=embedding_directory, parameters=parameters, tokenizer_data=tokenizer_data, model_options=model_options) for c in clip_data: @@ -525,11 +525,11 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip return clip def load_gligen(ckpt_path): - data = comfy.utils.load_torch_file(ckpt_path, safe_load=True) + data = seap.utils.load_torch_file(ckpt_path, safe_load=True) model = gligen.load_gligen(data) if model_management.should_use_fp16(): model = model.half() - return comfy.model_patcher.ModelPatcher(model, load_device=model_management.get_torch_device(), offload_device=model_management.unet_offload_device()) + return seap.model_patcher.ModelPatcher(model, load_device=model_management.get_torch_device(), offload_device=model_management.unet_offload_device()) def load_checkpoint(config_path=None, ckpt_path=None, output_vae=True, output_clip=True, embedding_directory=None, state_dict=None, config=None): logging.warning("Warning: The load checkpoint with config function is deprecated and will eventually be removed, please use the other one.") @@ -545,7 +545,7 @@ def load_checkpoint(config_path=None, ckpt_path=None, output_vae=True, output_cl if "parameterization" in model_config_params: if model_config_params["parameterization"] == "v": m = model.clone() - class ModelSamplingAdvanced(comfy.model_sampling.ModelSamplingDiscrete, comfy.model_sampling.V_PREDICTION): + class ModelSamplingAdvanced(seap.model_sampling.ModelSamplingDiscrete, seap.model_sampling.V_PREDICTION): pass m.add_object_patch("model_sampling", ModelSamplingAdvanced(model.model.model_config)) model = m @@ -557,7 +557,7 @@ def load_checkpoint(config_path=None, ckpt_path=None, output_vae=True, output_cl return (model, clip, vae) def load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=False, embedding_directory=None, output_model=True, model_options={}, te_model_options={}): - sd = comfy.utils.load_torch_file(ckpt_path) + sd = seap.utils.load_torch_file(ckpt_path) out = load_state_dict_guess_config(sd, output_vae, output_clip, output_clipvision, embedding_directory, output_model, model_options, te_model_options=te_model_options) if out is None: raise RuntimeError("ERROR: Could not detect model type of: {}".format(ckpt_path)) @@ -571,8 +571,8 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c model_patcher = None diffusion_model_prefix = model_detection.unet_prefix_from_state_dict(sd) - parameters = comfy.utils.calculate_parameters(sd, diffusion_model_prefix) - weight_dtype = comfy.utils.weight_dtype(sd, diffusion_model_prefix) + parameters = seap.utils.calculate_parameters(sd, diffusion_model_prefix) + weight_dtype = seap.utils.weight_dtype(sd, diffusion_model_prefix) load_device = model_management.get_torch_device() model_config = model_detection.model_config_from_unet(sd, diffusion_model_prefix) @@ -602,7 +602,7 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c model.load_model_weights(sd, diffusion_model_prefix) if output_vae: - vae_sd = comfy.utils.state_dict_prefix_replace(sd, {k: "" for k in model_config.vae_key_prefix}, filter_keys=True) + vae_sd = seap.utils.state_dict_prefix_replace(sd, {k: "" for k in model_config.vae_key_prefix}, filter_keys=True) vae_sd = model_config.process_vae_state_dict(vae_sd) vae = VAE(sd=vae_sd) @@ -611,7 +611,7 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c if clip_target is not None: clip_sd = model_config.process_clip_state_dict(sd) if len(clip_sd) > 0: - parameters = comfy.utils.calculate_parameters(clip_sd) + parameters = seap.utils.calculate_parameters(clip_sd) clip = CLIP(clip_target, embedding_directory=embedding_directory, tokenizer_data=clip_sd, parameters=parameters, model_options=te_model_options) m, u = clip.load_sd(clip_sd, full_model=True) if len(m) > 0: @@ -631,7 +631,7 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c logging.debug("left over keys: {}".format(left_over)) if output_model: - model_patcher = comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device()) + model_patcher = seap.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=model_management.unet_offload_device()) if inital_load_device != torch.device("cpu"): logging.info("loaded straight to GPU") model_management.load_models_gpu([model_patcher], force_full_load=True) @@ -644,11 +644,11 @@ def load_diffusion_model_state_dict(sd, model_options={}): #load unet in diffuse #Allow loading unets from checkpoint files diffusion_model_prefix = model_detection.unet_prefix_from_state_dict(sd) - temp_sd = comfy.utils.state_dict_prefix_replace(sd, {diffusion_model_prefix: ""}, filter_keys=True) + temp_sd = seap.utils.state_dict_prefix_replace(sd, {diffusion_model_prefix: ""}, filter_keys=True) if len(temp_sd) > 0: sd = temp_sd - parameters = comfy.utils.calculate_parameters(sd) + parameters = seap.utils.calculate_parameters(sd) load_device = model_management.get_torch_device() model_config = model_detection.model_config_from_unet(sd, "") @@ -665,7 +665,7 @@ def load_diffusion_model_state_dict(sd, model_options={}): #load unet in diffuse if model_config is None: return None - diffusers_keys = comfy.utils.unet_to_diffusers(model_config.unet_config) + diffusers_keys = seap.utils.unet_to_diffusers(model_config.unet_config) new_sd = {} for k in diffusers_keys: @@ -692,11 +692,11 @@ def load_diffusion_model_state_dict(sd, model_options={}): #load unet in diffuse left_over = sd.keys() if len(left_over) > 0: logging.info("left over keys in unet: {}".format(left_over)) - return comfy.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=offload_device) + return seap.model_patcher.ModelPatcher(model, load_device=load_device, offload_device=offload_device) def load_diffusion_model(unet_path, model_options={}): - sd = comfy.utils.load_torch_file(unet_path) + sd = seap.utils.load_torch_file(unet_path) model = load_diffusion_model_state_dict(sd, model_options=model_options) if model is None: logging.error("ERROR UNSUPPORTED UNET {}".format(unet_path)) @@ -732,4 +732,4 @@ def save_checkpoint(output_path, model, clip=None, vae=None, clip_vision=None, m if not t.is_contiguous(): sd[k] = t.contiguous() - comfy.utils.save_torch_file(sd, output_path, metadata=metadata) + seap.utils.save_torch_file(sd, output_path, metadata=metadata) diff --git a/comfy/sd1_clip.py b/seap/sd1_clip.py similarity index 99% rename from comfy/sd1_clip.py rename to seap/sd1_clip.py index 6f574900f..2a8718752 100644 --- a/comfy/sd1_clip.py +++ b/seap/sd1_clip.py @@ -1,12 +1,12 @@ import os from transformers import CLIPTokenizer -import comfy.ops +import seap.ops import torch import traceback import zipfile from . import model_management -import comfy.clip_model +import seap.clip_model import json import logging import numbers @@ -81,7 +81,7 @@ class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder): "hidden" ] def __init__(self, device="cpu", max_length=77, - freeze=True, layer="last", layer_idx=None, textmodel_json_config=None, dtype=None, model_class=comfy.clip_model.CLIPTextModel, + freeze=True, layer="last", layer_idx=None, textmodel_json_config=None, dtype=None, model_class=seap.clip_model.CLIPTextModel, special_tokens={"start": 49406, "end": 49407, "pad": 49407}, layer_norm_hidden_state=True, enable_attention_masks=False, zero_out_masked=False, return_projected_pooled=True, return_attention_masks=False, model_options={}): # clip-vit-base-patch32 super().__init__() @@ -95,7 +95,7 @@ class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder): operations = model_options.get("custom_operations", None) if operations is None: - operations = comfy.ops.manual_cast + operations = seap.ops.manual_cast self.operations = operations self.transformer = model_class(config, dtype, device, self.operations) diff --git a/comfy/sd1_clip_config.json b/seap/sd1_clip_config.json similarity index 100% rename from comfy/sd1_clip_config.json rename to seap/sd1_clip_config.json diff --git a/comfy/sd1_tokenizer/merges.txt b/seap/sd1_tokenizer/merges.txt similarity index 100% rename from comfy/sd1_tokenizer/merges.txt rename to seap/sd1_tokenizer/merges.txt diff --git a/comfy/sd1_tokenizer/special_tokens_map.json b/seap/sd1_tokenizer/special_tokens_map.json similarity index 100% rename from comfy/sd1_tokenizer/special_tokens_map.json rename to seap/sd1_tokenizer/special_tokens_map.json diff --git a/comfy/sd1_tokenizer/tokenizer_config.json b/seap/sd1_tokenizer/tokenizer_config.json similarity index 100% rename from comfy/sd1_tokenizer/tokenizer_config.json rename to seap/sd1_tokenizer/tokenizer_config.json diff --git a/comfy/sd1_tokenizer/vocab.json b/seap/sd1_tokenizer/vocab.json similarity index 100% rename from comfy/sd1_tokenizer/vocab.json rename to seap/sd1_tokenizer/vocab.json diff --git a/comfy/sdxl_clip.py b/seap/sdxl_clip.py similarity index 99% rename from comfy/sdxl_clip.py rename to seap/sdxl_clip.py index 4d0a4e8e7..1587946a1 100644 --- a/comfy/sdxl_clip.py +++ b/seap/sdxl_clip.py @@ -1,4 +1,4 @@ -from comfy import sd1_clip +from seap import sd1_clip import torch import os diff --git a/comfy/supported_models.py b/seap/supported_models.py similarity index 95% rename from comfy/supported_models.py rename to seap/supported_models.py index 3603313fa..38b757e85 100644 --- a/comfy/supported_models.py +++ b/seap/supported_models.py @@ -4,12 +4,12 @@ from . import utils from . import sd1_clip from . import sdxl_clip -import comfy.text_encoders.sd2_clip -import comfy.text_encoders.sd3_clip -import comfy.text_encoders.sa_t5 -import comfy.text_encoders.aura_t5 -import comfy.text_encoders.hydit -import comfy.text_encoders.flux +import seap.text_encoders.sd2_clip +import seap.text_encoders.sd3_clip +import seap.text_encoders.sa_t5 +import seap.text_encoders.aura_t5 +import seap.text_encoders.hydit +import seap.text_encoders.flux from . import supported_models_base from . import latent_formats @@ -104,7 +104,7 @@ class SD20(supported_models_base.BASE): return state_dict def clip_target(self, state_dict={}): - return supported_models_base.ClipTarget(comfy.text_encoders.sd2_clip.SD2Tokenizer, comfy.text_encoders.sd2_clip.SD2ClipModel) + return supported_models_base.ClipTarget(seap.text_encoders.sd2_clip.SD2Tokenizer, seap.text_encoders.sd2_clip.SD2ClipModel) class SD21UnclipL(SD20): unet_config = { @@ -534,7 +534,7 @@ class SD3(supported_models_base.BASE): t5 = True dtype_t5 = state_dict[t5_key].dtype - return supported_models_base.ClipTarget(comfy.text_encoders.sd3_clip.SD3Tokenizer, comfy.text_encoders.sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5)) + return supported_models_base.ClipTarget(seap.text_encoders.sd3_clip.SD3Tokenizer, seap.text_encoders.sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5)) class StableAudio(supported_models_base.BASE): unet_config = { @@ -565,7 +565,7 @@ class StableAudio(supported_models_base.BASE): return utils.state_dict_prefix_replace(state_dict, replace_prefix) def clip_target(self, state_dict={}): - return supported_models_base.ClipTarget(comfy.text_encoders.sa_t5.SAT5Tokenizer, comfy.text_encoders.sa_t5.SAT5Model) + return supported_models_base.ClipTarget(seap.text_encoders.sa_t5.SAT5Tokenizer, seap.text_encoders.sa_t5.SAT5Model) class AuraFlow(supported_models_base.BASE): unet_config = { @@ -588,7 +588,7 @@ class AuraFlow(supported_models_base.BASE): return out def clip_target(self, state_dict={}): - return supported_models_base.ClipTarget(comfy.text_encoders.aura_t5.AuraT5Tokenizer, comfy.text_encoders.aura_t5.AuraT5Model) + return supported_models_base.ClipTarget(seap.text_encoders.aura_t5.AuraT5Tokenizer, seap.text_encoders.aura_t5.AuraT5Model) class HunyuanDiT(supported_models_base.BASE): unet_config = { @@ -614,7 +614,7 @@ class HunyuanDiT(supported_models_base.BASE): return out def clip_target(self, state_dict={}): - return supported_models_base.ClipTarget(comfy.text_encoders.hydit.HyditTokenizer, comfy.text_encoders.hydit.HyditModel) + return supported_models_base.ClipTarget(seap.text_encoders.hydit.HyditTokenizer, seap.text_encoders.hydit.HyditModel) class HunyuanDiT1(HunyuanDiT): unet_config = { @@ -657,7 +657,7 @@ class Flux(supported_models_base.BASE): dtype_t5 = None if t5_key in state_dict: dtype_t5 = state_dict[t5_key].dtype - return supported_models_base.ClipTarget(comfy.text_encoders.flux.FluxTokenizer, comfy.text_encoders.flux.flux_clip(dtype_t5=dtype_t5)) + return supported_models_base.ClipTarget(seap.text_encoders.flux.FluxTokenizer, seap.text_encoders.flux.flux_clip(dtype_t5=dtype_t5)) class FluxSchnell(Flux): unet_config = { diff --git a/comfy/supported_models_base.py b/seap/supported_models_base.py similarity index 100% rename from comfy/supported_models_base.py rename to seap/supported_models_base.py diff --git a/comfy/t2i_adapter/adapter.py b/seap/t2i_adapter/adapter.py similarity index 100% rename from comfy/t2i_adapter/adapter.py rename to seap/t2i_adapter/adapter.py diff --git a/comfy/taesd/taesd.py b/seap/taesd/taesd.py similarity index 85% rename from comfy/taesd/taesd.py rename to seap/taesd/taesd.py index ce36f1a84..b9c0b8b47 100644 --- a/comfy/taesd/taesd.py +++ b/seap/taesd/taesd.py @@ -6,11 +6,11 @@ Tiny AutoEncoder for Stable Diffusion import torch import torch.nn as nn -import comfy.utils -import comfy.ops +import seap.utils +import seap.ops def conv(n_in, n_out, **kwargs): - return comfy.ops.disable_weight_init.Conv2d(n_in, n_out, 3, padding=1, **kwargs) + return seap.ops.disable_weight_init.Conv2d(n_in, n_out, 3, padding=1, **kwargs) class Clamp(nn.Module): def forward(self, x): @@ -20,7 +20,7 @@ class Block(nn.Module): def __init__(self, n_in, n_out): super().__init__() self.conv = nn.Sequential(conv(n_in, n_out), nn.ReLU(), conv(n_out, n_out), nn.ReLU(), conv(n_out, n_out)) - self.skip = comfy.ops.disable_weight_init.Conv2d(n_in, n_out, 1, bias=False) if n_in != n_out else nn.Identity() + self.skip = seap.ops.disable_weight_init.Conv2d(n_in, n_out, 1, bias=False) if n_in != n_out else nn.Identity() self.fuse = nn.ReLU() def forward(self, x): return self.fuse(self.conv(x) + self.skip(x)) @@ -56,9 +56,9 @@ class TAESD(nn.Module): self.vae_scale = torch.nn.Parameter(torch.tensor(1.0)) self.vae_shift = torch.nn.Parameter(torch.tensor(0.0)) if encoder_path is not None: - self.taesd_encoder.load_state_dict(comfy.utils.load_torch_file(encoder_path, safe_load=True)) + self.taesd_encoder.load_state_dict(seap.utils.load_torch_file(encoder_path, safe_load=True)) if decoder_path is not None: - self.taesd_decoder.load_state_dict(comfy.utils.load_torch_file(decoder_path, safe_load=True)) + self.taesd_decoder.load_state_dict(seap.utils.load_torch_file(decoder_path, safe_load=True)) @staticmethod def scale_latents(x): diff --git a/comfy/text_encoders/aura_t5.py b/seap/text_encoders/aura_t5.py similarity index 86% rename from comfy/text_encoders/aura_t5.py rename to seap/text_encoders/aura_t5.py index e9ad45a7f..f3531a842 100644 --- a/comfy/text_encoders/aura_t5.py +++ b/seap/text_encoders/aura_t5.py @@ -1,12 +1,12 @@ -from comfy import sd1_clip +from seap import sd1_clip from .spiece_tokenizer import SPieceTokenizer -import comfy.text_encoders.t5 +import seap.text_encoders.t5 import os class PT5XlModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_pile_config_xl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 2, "pad": 1}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True, model_options=model_options) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 2, "pad": 1}, model_class=seap.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True, model_options=model_options) class PT5XlTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None, tokenizer_data={}): diff --git a/comfy/text_encoders/bert.py b/seap/text_encoders/bert.py similarity index 96% rename from comfy/text_encoders/bert.py rename to seap/text_encoders/bert.py index fc9bac1d2..eb4659037 100644 --- a/comfy/text_encoders/bert.py +++ b/seap/text_encoders/bert.py @@ -1,6 +1,6 @@ import torch -from comfy.ldm.modules.attention import optimized_attention_for_device -import comfy.ops +from seap.ldm.modules.attention import optimized_attention_for_device +import seap.ops class BertAttention(torch.nn.Module): def __init__(self, embed_dim, heads, dtype, device, operations): @@ -95,11 +95,11 @@ class BertEmbeddings(torch.nn.Module): def forward(self, input_tokens, token_type_ids=None, dtype=None): x = self.word_embeddings(input_tokens, out_dtype=dtype) - x += comfy.ops.cast_to_input(self.position_embeddings.weight[:x.shape[1]], x) + x += seap.ops.cast_to_input(self.position_embeddings.weight[:x.shape[1]], x) if token_type_ids is not None: x += self.token_type_embeddings(token_type_ids, out_dtype=x.dtype) else: - x += comfy.ops.cast_to_input(self.token_type_embeddings.weight[0], x) + x += seap.ops.cast_to_input(self.token_type_embeddings.weight[0], x) x = self.LayerNorm(x) return x diff --git a/comfy/text_encoders/flux.py b/seap/text_encoders/flux.py similarity index 92% rename from comfy/text_encoders/flux.py rename to seap/text_encoders/flux.py index b13fa5b4f..6fe98ac9e 100644 --- a/comfy/text_encoders/flux.py +++ b/seap/text_encoders/flux.py @@ -1,6 +1,6 @@ -from comfy import sd1_clip -import comfy.text_encoders.t5 -import comfy.model_management +from seap import sd1_clip +import seap.text_encoders.t5 +import seap.model_management from transformers import T5TokenizerFast import torch import os @@ -8,7 +8,7 @@ import os class T5XXLModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_xxl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, model_options=model_options) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=seap.text_encoders.t5.T5, model_options=model_options) class T5XXLTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None, tokenizer_data={}): @@ -38,7 +38,7 @@ class FluxTokenizer: class FluxClipModel(torch.nn.Module): def __init__(self, dtype_t5=None, device="cpu", dtype=None, model_options={}): super().__init__() - dtype_t5 = comfy.model_management.pick_weight_dtype(dtype_t5, dtype, device) + dtype_t5 = seap.model_management.pick_weight_dtype(dtype_t5, dtype, device) clip_l_class = model_options.get("clip_l_class", sd1_clip.SDClipModel) self.clip_l = clip_l_class(device=device, dtype=dtype, return_projected_pooled=False, model_options=model_options) self.t5xxl = T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options) diff --git a/comfy/text_encoders/hydit.py b/seap/text_encoders/hydit.py similarity index 94% rename from comfy/text_encoders/hydit.py rename to seap/text_encoders/hydit.py index 7cb790f45..757400648 100644 --- a/comfy/text_encoders/hydit.py +++ b/seap/text_encoders/hydit.py @@ -1,8 +1,8 @@ -from comfy import sd1_clip +from seap import sd1_clip from transformers import BertTokenizer from .spiece_tokenizer import SPieceTokenizer from .bert import BertModel -import comfy.text_encoders.t5 +import seap.text_encoders.t5 import os import torch @@ -20,7 +20,7 @@ class HyditBertTokenizer(sd1_clip.SDTokenizer): class MT5XLModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "mt5_config_xl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=True, return_attention_masks=True, model_options=model_options) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=seap.text_encoders.t5.T5, enable_attention_masks=True, return_attention_masks=True, model_options=model_options) class MT5XLTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None, tokenizer_data={}): diff --git a/comfy/text_encoders/hydit_clip.json b/seap/text_encoders/hydit_clip.json similarity index 100% rename from comfy/text_encoders/hydit_clip.json rename to seap/text_encoders/hydit_clip.json diff --git a/comfy/text_encoders/hydit_clip_tokenizer/special_tokens_map.json b/seap/text_encoders/hydit_clip_tokenizer/special_tokens_map.json similarity index 100% rename from comfy/text_encoders/hydit_clip_tokenizer/special_tokens_map.json rename to seap/text_encoders/hydit_clip_tokenizer/special_tokens_map.json diff --git a/comfy/text_encoders/hydit_clip_tokenizer/tokenizer_config.json b/seap/text_encoders/hydit_clip_tokenizer/tokenizer_config.json similarity index 100% rename from comfy/text_encoders/hydit_clip_tokenizer/tokenizer_config.json rename to seap/text_encoders/hydit_clip_tokenizer/tokenizer_config.json diff --git a/comfy/text_encoders/hydit_clip_tokenizer/vocab.txt b/seap/text_encoders/hydit_clip_tokenizer/vocab.txt similarity index 100% rename from comfy/text_encoders/hydit_clip_tokenizer/vocab.txt rename to seap/text_encoders/hydit_clip_tokenizer/vocab.txt diff --git a/comfy/text_encoders/long_clipl.json b/seap/text_encoders/long_clipl.json similarity index 100% rename from comfy/text_encoders/long_clipl.json rename to seap/text_encoders/long_clipl.json diff --git a/comfy/text_encoders/long_clipl.py b/seap/text_encoders/long_clipl.py similarity index 98% rename from comfy/text_encoders/long_clipl.py rename to seap/text_encoders/long_clipl.py index b81912cb3..8190f9178 100644 --- a/comfy/text_encoders/long_clipl.py +++ b/seap/text_encoders/long_clipl.py @@ -1,4 +1,4 @@ -from comfy import sd1_clip +from seap import sd1_clip import os class LongClipTokenizer_(sd1_clip.SDTokenizer): diff --git a/comfy/text_encoders/mt5_config_xl.json b/seap/text_encoders/mt5_config_xl.json similarity index 100% rename from comfy/text_encoders/mt5_config_xl.json rename to seap/text_encoders/mt5_config_xl.json diff --git a/comfy/text_encoders/sa_t5.py b/seap/text_encoders/sa_t5.py similarity index 90% rename from comfy/text_encoders/sa_t5.py rename to seap/text_encoders/sa_t5.py index 7778ce47a..7a4d3833a 100644 --- a/comfy/text_encoders/sa_t5.py +++ b/seap/text_encoders/sa_t5.py @@ -1,12 +1,12 @@ -from comfy import sd1_clip +from seap import sd1_clip from transformers import T5TokenizerFast -import comfy.text_encoders.t5 +import seap.text_encoders.t5 import os class T5BaseModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_base.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, model_options=model_options, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, model_options=model_options, special_tokens={"end": 1, "pad": 0}, model_class=seap.text_encoders.t5.T5, enable_attention_masks=True, zero_out_masked=True) class T5BaseTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None, tokenizer_data={}): diff --git a/comfy/text_encoders/sd2_clip.py b/seap/text_encoders/sd2_clip.py similarity index 98% rename from comfy/text_encoders/sd2_clip.py rename to seap/text_encoders/sd2_clip.py index 31fc89869..aa633ff51 100644 --- a/comfy/text_encoders/sd2_clip.py +++ b/seap/text_encoders/sd2_clip.py @@ -1,4 +1,4 @@ -from comfy import sd1_clip +from seap import sd1_clip import os class SD2ClipHModel(sd1_clip.SDClipModel): diff --git a/comfy/text_encoders/sd2_clip_config.json b/seap/text_encoders/sd2_clip_config.json similarity index 100% rename from comfy/text_encoders/sd2_clip_config.json rename to seap/text_encoders/sd2_clip_config.json diff --git a/comfy/text_encoders/sd3_clip.py b/seap/text_encoders/sd3_clip.py similarity index 88% rename from comfy/text_encoders/sd3_clip.py rename to seap/text_encoders/sd3_clip.py index 0340e65b8..cd92098e9 100644 --- a/comfy/text_encoders/sd3_clip.py +++ b/seap/text_encoders/sd3_clip.py @@ -1,16 +1,16 @@ -from comfy import sd1_clip -from comfy import sdxl_clip +from seap import sd1_clip +from seap import sdxl_clip from transformers import T5TokenizerFast -import comfy.text_encoders.t5 +import seap.text_encoders.t5 import torch import os -import comfy.model_management +import seap.model_management import logging class T5XXLModel(sd1_clip.SDClipModel): def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, attention_mask=False, model_options={}): textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_xxl.json") - super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options) + super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=seap.text_encoders.t5.T5, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options) class T5XXLTokenizer(sd1_clip.SDTokenizer): def __init__(self, embedding_directory=None, tokenizer_data={}): @@ -56,7 +56,7 @@ class SD3ClipModel(torch.nn.Module): self.clip_g = None if t5: - dtype_t5 = comfy.model_management.pick_weight_dtype(dtype_t5, dtype, device) + dtype_t5 = seap.model_management.pick_weight_dtype(dtype_t5, dtype, device) self.t5_attention_mask = t5_attention_mask self.t5xxl = T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options, attention_mask=self.t5_attention_mask) self.dtypes.add(dtype_t5) @@ -94,7 +94,7 @@ class SD3ClipModel(torch.nn.Module): if self.clip_l is not None: lg_out, l_pooled = self.clip_l.encode_token_weights(token_weight_pairs_l) else: - l_pooled = torch.zeros((1, 768), device=comfy.model_management.intermediate_device()) + l_pooled = torch.zeros((1, 768), device=seap.model_management.intermediate_device()) if self.clip_g is not None: g_out, g_pooled = self.clip_g.encode_token_weights(token_weight_pairs_g) @@ -105,7 +105,7 @@ class SD3ClipModel(torch.nn.Module): lg_out = torch.nn.functional.pad(g_out, (768, 0)) else: g_out = None - g_pooled = torch.zeros((1, 1280), device=comfy.model_management.intermediate_device()) + g_pooled = torch.zeros((1, 1280), device=seap.model_management.intermediate_device()) if lg_out is not None: lg_out = torch.nn.functional.pad(lg_out, (0, 4096 - lg_out.shape[-1])) @@ -124,10 +124,10 @@ class SD3ClipModel(torch.nn.Module): out = t5_out if out is None: - out = torch.zeros((1, 77, 4096), device=comfy.model_management.intermediate_device()) + out = torch.zeros((1, 77, 4096), device=seap.model_management.intermediate_device()) if pooled is None: - pooled = torch.zeros((1, 768 + 1280), device=comfy.model_management.intermediate_device()) + pooled = torch.zeros((1, 768 + 1280), device=seap.model_management.intermediate_device()) return out, pooled, extra diff --git a/comfy/text_encoders/spiece_tokenizer.py b/seap/text_encoders/spiece_tokenizer.py similarity index 100% rename from comfy/text_encoders/spiece_tokenizer.py rename to seap/text_encoders/spiece_tokenizer.py diff --git a/comfy/text_encoders/t5.py b/seap/text_encoders/t5.py similarity index 98% rename from comfy/text_encoders/t5.py rename to seap/text_encoders/t5.py index a1420c6cd..7b53347c5 100644 --- a/comfy/text_encoders/t5.py +++ b/seap/text_encoders/t5.py @@ -1,7 +1,7 @@ import torch import math -from comfy.ldm.modules.attention import optimized_attention_for_device -import comfy.ops +from seap.ldm.modules.attention import optimized_attention_for_device +import seap.ops class T5LayerNorm(torch.nn.Module): def __init__(self, hidden_size, eps=1e-6, dtype=None, device=None, operations=None): @@ -12,7 +12,7 @@ class T5LayerNorm(torch.nn.Module): def forward(self, x): variance = x.pow(2).mean(-1, keepdim=True) x = x * torch.rsqrt(variance + self.variance_epsilon) - return comfy.ops.cast_to_input(self.weight, x) * x + return seap.ops.cast_to_input(self.weight, x) * x activations = { "gelu_pytorch_tanh": lambda a: torch.nn.functional.gelu(a, approximate="tanh"), diff --git a/comfy/text_encoders/t5_config_base.json b/seap/text_encoders/t5_config_base.json similarity index 100% rename from comfy/text_encoders/t5_config_base.json rename to seap/text_encoders/t5_config_base.json diff --git a/comfy/text_encoders/t5_config_xxl.json b/seap/text_encoders/t5_config_xxl.json similarity index 100% rename from comfy/text_encoders/t5_config_xxl.json rename to seap/text_encoders/t5_config_xxl.json diff --git a/comfy/text_encoders/t5_pile_config_xl.json b/seap/text_encoders/t5_pile_config_xl.json similarity index 100% rename from comfy/text_encoders/t5_pile_config_xl.json rename to seap/text_encoders/t5_pile_config_xl.json diff --git a/comfy/text_encoders/t5_pile_tokenizer/tokenizer.model b/seap/text_encoders/t5_pile_tokenizer/tokenizer.model similarity index 100% rename from comfy/text_encoders/t5_pile_tokenizer/tokenizer.model rename to seap/text_encoders/t5_pile_tokenizer/tokenizer.model diff --git a/comfy/text_encoders/t5_tokenizer/special_tokens_map.json b/seap/text_encoders/t5_tokenizer/special_tokens_map.json similarity index 100% rename from comfy/text_encoders/t5_tokenizer/special_tokens_map.json rename to seap/text_encoders/t5_tokenizer/special_tokens_map.json diff --git a/comfy/text_encoders/t5_tokenizer/tokenizer.json b/seap/text_encoders/t5_tokenizer/tokenizer.json similarity index 100% rename from comfy/text_encoders/t5_tokenizer/tokenizer.json rename to seap/text_encoders/t5_tokenizer/tokenizer.json diff --git a/comfy/text_encoders/t5_tokenizer/tokenizer_config.json b/seap/text_encoders/t5_tokenizer/tokenizer_config.json similarity index 100% rename from comfy/text_encoders/t5_tokenizer/tokenizer_config.json rename to seap/text_encoders/t5_tokenizer/tokenizer_config.json diff --git a/comfy/utils.py b/seap/utils.py similarity index 99% rename from comfy/utils.py rename to seap/utils.py index 78f8314fc..dbc011668 100644 --- a/comfy/utils.py +++ b/seap/utils.py @@ -20,7 +20,7 @@ import torch import math import struct -import comfy.checkpoint_pickle +import seap.checkpoint_pickle import safetensors.torch import numpy as np from PIL import Image @@ -40,7 +40,7 @@ def load_torch_file(ckpt, safe_load=False, device=None): if safe_load: pl_sd = torch.load(ckpt, map_location=device, weights_only=True) else: - pl_sd = torch.load(ckpt, map_location=device, pickle_module=comfy.checkpoint_pickle) + pl_sd = torch.load(ckpt, map_location=device, pickle_module=seap.checkpoint_pickle) if "global_step" in pl_sd: logging.debug(f"Global Step: {pl_sd['global_step']}") if "state_dict" in pl_sd: diff --git a/comfy_execution/caching.py b/seap_execution/caching.py similarity index 99% rename from comfy_execution/caching.py rename to seap_execution/caching.py index 630f280fc..5aab12481 100644 --- a/comfy_execution/caching.py +++ b/seap_execution/caching.py @@ -1,10 +1,10 @@ import itertools from typing import Sequence, Mapping, Dict -from comfy_execution.graph import DynamicPrompt +from seap_execution.graph import DynamicPrompt import nodes -from comfy_execution.graph_utils import is_link +from seap_execution.graph_utils import is_link NODE_CLASS_CONTAINS_UNIQUE_ID: Dict[str, bool] = {} diff --git a/comfy_execution/graph.py b/seap_execution/graph.py similarity index 99% rename from comfy_execution/graph.py rename to seap_execution/graph.py index 0b5bf1899..8951ed289 100644 --- a/comfy_execution/graph.py +++ b/seap_execution/graph.py @@ -1,6 +1,6 @@ import nodes -from comfy_execution.graph_utils import is_link +from seap_execution.graph_utils import is_link class DependencyCycleError(Exception): pass diff --git a/comfy_execution/graph_utils.py b/seap_execution/graph_utils.py similarity index 100% rename from comfy_execution/graph_utils.py rename to seap_execution/graph_utils.py diff --git a/comfy_extras/chainner_models/model_loading.py b/seap_extras/chainner_models/model_loading.py similarity index 54% rename from comfy_extras/chainner_models/model_loading.py rename to seap_extras/chainner_models/model_loading.py index d48bc238c..ead38a5cb 100644 --- a/comfy_extras/chainner_models/model_loading.py +++ b/seap_extras/chainner_models/model_loading.py @@ -1,5 +1,5 @@ from spandrel import ModelLoader def load_state_dict(state_dict): - print("WARNING: comfy_extras.chainner_models is deprecated and has been replaced by the spandrel library.") + print("WARNING: seap_extras.chainner_models is deprecated and has been replaced by the spandrel library.") return ModelLoader().load_from_state_dict(state_dict).eval() diff --git a/comfy_extras/nodes_advanced_samplers.py b/seap_extras/nodes_advanced_samplers.py similarity index 81% rename from comfy_extras/nodes_advanced_samplers.py rename to seap_extras/nodes_advanced_samplers.py index 820c250ef..469ffddbd 100644 --- a/comfy_extras/nodes_advanced_samplers.py +++ b/seap_extras/nodes_advanced_samplers.py @@ -1,5 +1,5 @@ -import comfy.samplers -import comfy.utils +import seap.samplers +import seap.utils import torch import numpy as np from tqdm.auto import trange, tqdm @@ -27,7 +27,7 @@ def sample_lcm_upscale(model, x, sigmas, extra_args=None, callback=None, disable x = denoised if i < len(upscales): - x = comfy.utils.common_upscale(x, round(orig_shape[-1] * upscales[i]), round(orig_shape[-2] * upscales[i]), upscale_method, "disabled") + x = seap.utils.common_upscale(x, round(orig_shape[-1] * upscales[i]), round(orig_shape[-2] * upscales[i]), upscale_method, "disabled") if sigmas[i + 1] > 0: x += sigmas[i + 1] * torch.randn_like(x) @@ -53,11 +53,11 @@ class SamplerLCMUpscale: def get_sampler(self, scale_ratio, scale_steps, upscale_method): if scale_steps < 0: scale_steps = None - sampler = comfy.samplers.KSAMPLER(sample_lcm_upscale, extra_options={"total_upscale": scale_ratio, "upscale_steps": scale_steps, "upscale_method": upscale_method}) + sampler = seap.samplers.KSAMPLER(sample_lcm_upscale, extra_options={"total_upscale": scale_ratio, "upscale_steps": scale_steps, "upscale_method": upscale_method}) return (sampler, ) -from comfy.k_diffusion.sampling import to_d -import comfy.model_patcher +from seap.k_diffusion.sampling import to_d +import seap.model_patcher @torch.no_grad() def sample_euler_pp(model, x, sigmas, extra_args=None, callback=None, disable=None): @@ -69,7 +69,7 @@ def sample_euler_pp(model, x, sigmas, extra_args=None, callback=None, disable=No return args["denoised"] model_options = extra_args.get("model_options", {}).copy() - extra_args["model_options"] = comfy.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) + extra_args["model_options"] = seap.model_patcher.set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True) s_in = x.new_ones([x.shape[0]]) for i in trange(len(sigmas) - 1, disable=disable): @@ -97,9 +97,9 @@ class SamplerEulerCFGpp: def get_sampler(self, version): if version == "alternative": - sampler = comfy.samplers.KSAMPLER(sample_euler_pp) + sampler = seap.samplers.KSAMPLER(sample_euler_pp) else: - sampler = comfy.samplers.ksampler("euler_cfg_pp") + sampler = seap.samplers.ksampler("euler_cfg_pp") return (sampler, ) NODE_CLASS_MAPPINGS = { diff --git a/comfy_extras/nodes_align_your_steps.py b/seap_extras/nodes_align_your_steps.py similarity index 100% rename from comfy_extras/nodes_align_your_steps.py rename to seap_extras/nodes_align_your_steps.py diff --git a/comfy_extras/nodes_attention_multiply.py b/seap_extras/nodes_attention_multiply.py similarity index 100% rename from comfy_extras/nodes_attention_multiply.py rename to seap_extras/nodes_attention_multiply.py diff --git a/comfy_extras/nodes_audio.py b/seap_extras/nodes_audio.py similarity index 98% rename from comfy_extras/nodes_audio.py rename to seap_extras/nodes_audio.py index e5cc4dffe..ae00fb999 100644 --- a/comfy_extras/nodes_audio.py +++ b/seap_extras/nodes_audio.py @@ -1,6 +1,6 @@ import torchaudio import torch -import comfy.model_management +import seap.model_management import folder_paths import os import io @@ -8,11 +8,11 @@ import json import struct import random import hashlib -from comfy.cli_args import args +from seap.cli_args import args class EmptyLatentAudio: def __init__(self): - self.device = comfy.model_management.intermediate_device() + self.device = seap.model_management.intermediate_device() @classmethod def INPUT_TYPES(s): diff --git a/comfy_extras/nodes_canny.py b/seap_extras/nodes_canny.py similarity index 71% rename from comfy_extras/nodes_canny.py rename to seap_extras/nodes_canny.py index d85e6b856..f967d1a55 100644 --- a/comfy_extras/nodes_canny.py +++ b/seap_extras/nodes_canny.py @@ -1,5 +1,5 @@ from kornia.filters import canny -import comfy.model_management +import seap.model_management class Canny: @@ -16,8 +16,8 @@ class Canny: CATEGORY = "image/preprocessors" def detect_edge(self, image, low_threshold, high_threshold): - output = canny(image.to(comfy.model_management.get_torch_device()).movedim(-1, 1), low_threshold, high_threshold) - img_out = output[1].to(comfy.model_management.intermediate_device()).repeat(1, 3, 1, 1).movedim(1, -1) + output = canny(image.to(seap.model_management.get_torch_device()).movedim(-1, 1), low_threshold, high_threshold) + img_out = output[1].to(seap.model_management.intermediate_device()).repeat(1, 3, 1, 1).movedim(1, -1) return (img_out,) NODE_CLASS_MAPPINGS = { diff --git a/comfy_extras/nodes_clip_sdxl.py b/seap_extras/nodes_clip_sdxl.py similarity index 100% rename from comfy_extras/nodes_clip_sdxl.py rename to seap_extras/nodes_clip_sdxl.py diff --git a/comfy_extras/nodes_compositing.py b/seap_extras/nodes_compositing.py similarity index 94% rename from comfy_extras/nodes_compositing.py rename to seap_extras/nodes_compositing.py index 48fe5e3dd..9f0275950 100644 --- a/comfy_extras/nodes_compositing.py +++ b/seap_extras/nodes_compositing.py @@ -1,6 +1,6 @@ import numpy as np import torch -import comfy.utils +import seap.utils from enum import Enum def resize_mask(mask, shape): @@ -135,15 +135,15 @@ class PorterDuffImageComposite: if dst_alpha.shape[:2] != dst_image.shape[:2]: upscale_input = dst_alpha.unsqueeze(0).permute(0, 3, 1, 2) - upscale_output = comfy.utils.common_upscale(upscale_input, dst_image.shape[1], dst_image.shape[0], upscale_method='bicubic', crop='center') + upscale_output = seap.utils.common_upscale(upscale_input, dst_image.shape[1], dst_image.shape[0], upscale_method='bicubic', crop='center') dst_alpha = upscale_output.permute(0, 2, 3, 1).squeeze(0) if src_image.shape != dst_image.shape: upscale_input = src_image.unsqueeze(0).permute(0, 3, 1, 2) - upscale_output = comfy.utils.common_upscale(upscale_input, dst_image.shape[1], dst_image.shape[0], upscale_method='bicubic', crop='center') + upscale_output = seap.utils.common_upscale(upscale_input, dst_image.shape[1], dst_image.shape[0], upscale_method='bicubic', crop='center') src_image = upscale_output.permute(0, 2, 3, 1).squeeze(0) if src_alpha.shape != dst_alpha.shape: upscale_input = src_alpha.unsqueeze(0).permute(0, 3, 1, 2) - upscale_output = comfy.utils.common_upscale(upscale_input, dst_alpha.shape[1], dst_alpha.shape[0], upscale_method='bicubic', crop='center') + upscale_output = seap.utils.common_upscale(upscale_input, dst_alpha.shape[1], dst_alpha.shape[0], upscale_method='bicubic', crop='center') src_alpha = upscale_output.permute(0, 2, 3, 1).squeeze(0) out_image, out_alpha = porter_duff_composite(src_image, src_alpha, dst_image, dst_alpha, PorterDuffMode[mode]) diff --git a/comfy_extras/nodes_cond.py b/seap_extras/nodes_cond.py similarity index 100% rename from comfy_extras/nodes_cond.py rename to seap_extras/nodes_cond.py diff --git a/comfy_extras/nodes_controlnet.py b/seap_extras/nodes_controlnet.py similarity index 92% rename from comfy_extras/nodes_controlnet.py rename to seap_extras/nodes_controlnet.py index 2d20e1fed..228ca8347 100644 --- a/comfy_extras/nodes_controlnet.py +++ b/seap_extras/nodes_controlnet.py @@ -1,6 +1,6 @@ -from comfy.cldm.control_types import UNION_CONTROLNET_TYPES +from seap.cldm.control_types import UNION_CONTROLNET_TYPES import nodes -import comfy.utils +import seap.utils class SetUnionControlNetType: @classmethod @@ -46,7 +46,7 @@ class ControlNetInpaintingAliMamaApply(nodes.ControlNetApplyAdvanced): extra_concat = [] if control_net.concat_mask: mask = 1.0 - mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])) - mask_apply = comfy.utils.common_upscale(mask, image.shape[2], image.shape[1], "bilinear", "center").round() + mask_apply = seap.utils.common_upscale(mask, image.shape[2], image.shape[1], "bilinear", "center").round() image = image * mask_apply.movedim(1, -1).repeat(1, 1, 1, image.shape[3]) extra_concat = [mask] diff --git a/comfy_extras/nodes_custom_sampler.py b/seap_extras/nodes_custom_sampler.py similarity index 90% rename from comfy_extras/nodes_custom_sampler.py rename to seap_extras/nodes_custom_sampler.py index c7ff9a4d8..7d115bc17 100644 --- a/comfy_extras/nodes_custom_sampler.py +++ b/seap_extras/nodes_custom_sampler.py @@ -1,9 +1,9 @@ -import comfy.samplers -import comfy.sample -from comfy.k_diffusion import sampling as k_diffusion_sampling +import seap.samplers +import seap.sample +from seap.k_diffusion import sampling as k_diffusion_sampling import latent_preview import torch -import comfy.utils +import seap.utils import node_helpers @@ -12,7 +12,7 @@ class BasicScheduler: def INPUT_TYPES(s): return {"required": {"model": ("MODEL",), - "scheduler": (comfy.samplers.SCHEDULER_NAMES, ), + "scheduler": (seap.samplers.SCHEDULER_NAMES,), "steps": ("INT", {"default": 20, "min": 1, "max": 10000}), "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), } @@ -29,7 +29,7 @@ class BasicScheduler: return (torch.FloatTensor([]),) total_steps = int(steps/denoise) - sigmas = comfy.samplers.calculate_sigmas(model.get_model_object("model_sampling"), scheduler, total_steps).cpu() + sigmas = seap.samplers.calculate_sigmas(model.get_model_object("model_sampling"), scheduler, total_steps).cpu() sigmas = sigmas[-(steps + 1):] return (sigmas, ) @@ -148,7 +148,7 @@ class BetaSamplingScheduler: FUNCTION = "get_sigmas" def get_sigmas(self, model, steps, alpha, beta): - sigmas = comfy.samplers.beta_scheduler(model.get_model_object("model_sampling"), steps, alpha=alpha, beta=beta) + sigmas = seap.samplers.beta_scheduler(model.get_model_object("model_sampling"), steps, alpha=alpha, beta=beta) return (sigmas, ) class VPScheduler: @@ -235,7 +235,7 @@ class KSamplerSelect: @classmethod def INPUT_TYPES(s): return {"required": - {"sampler_name": (comfy.samplers.SAMPLER_NAMES, ), + {"sampler_name": (seap.samplers.SAMPLER_NAMES,), } } RETURN_TYPES = ("SAMPLER",) @@ -244,7 +244,7 @@ class KSamplerSelect: FUNCTION = "get_sampler" def get_sampler(self, sampler_name): - sampler = comfy.samplers.sampler_object(sampler_name) + sampler = seap.samplers.sampler_object(sampler_name) return (sampler, ) class SamplerDPMPP_3M_SDE: @@ -266,7 +266,7 @@ class SamplerDPMPP_3M_SDE: sampler_name = "dpmpp_3m_sde" else: sampler_name = "dpmpp_3m_sde_gpu" - sampler = comfy.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise}) + sampler = seap.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise}) return (sampler, ) class SamplerDPMPP_2M_SDE: @@ -289,7 +289,7 @@ class SamplerDPMPP_2M_SDE: sampler_name = "dpmpp_2m_sde" else: sampler_name = "dpmpp_2m_sde_gpu" - sampler = comfy.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise, "solver_type": solver_type}) + sampler = seap.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise, "solver_type": solver_type}) return (sampler, ) @@ -313,7 +313,7 @@ class SamplerDPMPP_SDE: sampler_name = "dpmpp_sde" else: sampler_name = "dpmpp_sde_gpu" - sampler = comfy.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise, "r": r}) + sampler = seap.samplers.ksampler(sampler_name, {"eta": eta, "s_noise": s_noise, "r": r}) return (sampler, ) class SamplerDPMPP_2S_Ancestral: @@ -330,7 +330,7 @@ class SamplerDPMPP_2S_Ancestral: FUNCTION = "get_sampler" def get_sampler(self, eta, s_noise): - sampler = comfy.samplers.ksampler("dpmpp_2s_ancestral", {"eta": eta, "s_noise": s_noise}) + sampler = seap.samplers.ksampler("dpmpp_2s_ancestral", {"eta": eta, "s_noise": s_noise}) return (sampler, ) class SamplerEulerAncestral: @@ -347,7 +347,7 @@ class SamplerEulerAncestral: FUNCTION = "get_sampler" def get_sampler(self, eta, s_noise): - sampler = comfy.samplers.ksampler("euler_ancestral", {"eta": eta, "s_noise": s_noise}) + sampler = seap.samplers.ksampler("euler_ancestral", {"eta": eta, "s_noise": s_noise}) return (sampler, ) class SamplerEulerAncestralCFGPP: @@ -364,7 +364,7 @@ class SamplerEulerAncestralCFGPP: FUNCTION = "get_sampler" def get_sampler(self, eta, s_noise): - sampler = comfy.samplers.ksampler( + sampler = seap.samplers.ksampler( "euler_ancestral_cfg_pp", {"eta": eta, "s_noise": s_noise}) return (sampler, ) @@ -382,7 +382,7 @@ class SamplerLMS: FUNCTION = "get_sampler" def get_sampler(self, order): - sampler = comfy.samplers.ksampler("lms", {"order": order}) + sampler = seap.samplers.ksampler("lms", {"order": order}) return (sampler, ) class SamplerDPMAdaptative: @@ -407,9 +407,9 @@ class SamplerDPMAdaptative: FUNCTION = "get_sampler" def get_sampler(self, order, rtol, atol, h_init, pcoeff, icoeff, dcoeff, accept_safety, eta, s_noise): - sampler = comfy.samplers.ksampler("dpm_adaptive", {"order": order, "rtol": rtol, "atol": atol, "h_init": h_init, "pcoeff": pcoeff, + sampler = seap.samplers.ksampler("dpm_adaptive", {"order": order, "rtol": rtol, "atol": atol, "h_init": h_init, "pcoeff": pcoeff, "icoeff": icoeff, "dcoeff": dcoeff, "accept_safety": accept_safety, "eta": eta, - "s_noise":s_noise }) + "s_noise":s_noise}) return (sampler, ) class Noise_EmptyNoise: @@ -428,7 +428,7 @@ class Noise_RandomNoise: def generate_noise(self, input_latent): latent_image = input_latent["samples"] batch_inds = input_latent["batch_index"] if "batch_index" in input_latent else None - return comfy.sample.prepare_noise(latent_image, self.seed, batch_inds) + return seap.sample.prepare_noise(latent_image, self.seed, batch_inds) class SamplerCustom: @classmethod @@ -457,7 +457,7 @@ class SamplerCustom: latent = latent_image latent_image = latent["samples"] latent = latent.copy() - latent_image = comfy.sample.fix_empty_latent_channels(model, latent_image) + latent_image = seap.sample.fix_empty_latent_channels(model, latent_image) latent["samples"] = latent_image if not add_noise: @@ -472,8 +472,8 @@ class SamplerCustom: x0_output = {} callback = latent_preview.prepare_callback(model, sigmas.shape[-1] - 1, x0_output) - disable_pbar = not comfy.utils.PROGRESS_BAR_ENABLED - samples = comfy.sample.sample_custom(model, noise, cfg, sampler, sigmas, positive, negative, latent_image, noise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=noise_seed) + disable_pbar = not seap.utils.PROGRESS_BAR_ENABLED + samples = seap.sample.sample_custom(model, noise, cfg, sampler, sigmas, positive, negative, latent_image, noise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=noise_seed) out = latent.copy() out["samples"] = samples @@ -484,7 +484,7 @@ class SamplerCustom: out_denoised = out return (out, out_denoised) -class Guider_Basic(comfy.samplers.CFGGuider): +class Guider_Basic(seap.samplers.CFGGuider): def set_conds(self, positive): self.inner_set_conds({"positive": positive}) @@ -524,12 +524,12 @@ class CFGGuider: CATEGORY = "sampling/custom_sampling/guiders" def get_guider(self, model, positive, negative, cfg): - guider = comfy.samplers.CFGGuider(model) + guider = seap.samplers.CFGGuider(model) guider.set_conds(positive, negative) guider.set_cfg(cfg) return (guider,) -class Guider_DualCFG(comfy.samplers.CFGGuider): +class Guider_DualCFG(seap.samplers.CFGGuider): def set_cfg(self, cfg1, cfg2): self.cfg1 = cfg1 self.cfg2 = cfg2 @@ -542,8 +542,8 @@ class Guider_DualCFG(comfy.samplers.CFGGuider): negative_cond = self.conds.get("negative", None) middle_cond = self.conds.get("middle", None) - out = comfy.samplers.calc_cond_batch(self.inner_model, [negative_cond, middle_cond, self.conds.get("positive", None)], x, timestep, model_options) - return comfy.samplers.cfg_function(self.inner_model, out[1], out[0], self.cfg2, x, timestep, model_options=model_options, cond=middle_cond, uncond=negative_cond) + (out[2] - out[1]) * self.cfg1 + out = seap.samplers.calc_cond_batch(self.inner_model, [negative_cond, middle_cond, self.conds.get("positive", None)], x, timestep, model_options) + return seap.samplers.cfg_function(self.inner_model, out[1], out[0], self.cfg2, x, timestep, model_options=model_options, cond=middle_cond, uncond=negative_cond) + (out[2] - out[1]) * self.cfg1 class DualCFGGuider: @classmethod @@ -619,7 +619,7 @@ class SamplerCustomAdvanced: latent = latent_image latent_image = latent["samples"] latent = latent.copy() - latent_image = comfy.sample.fix_empty_latent_channels(guider.model_patcher, latent_image) + latent_image = seap.sample.fix_empty_latent_channels(guider.model_patcher, latent_image) latent["samples"] = latent_image noise_mask = None @@ -629,9 +629,9 @@ class SamplerCustomAdvanced: x0_output = {} callback = latent_preview.prepare_callback(guider.model_patcher, sigmas.shape[-1] - 1, x0_output) - disable_pbar = not comfy.utils.PROGRESS_BAR_ENABLED + disable_pbar = not seap.utils.PROGRESS_BAR_ENABLED samples = guider.sample(noise.generate_noise(latent), latent_image, sampler, sigmas, denoise_mask=noise_mask, callback=callback, disable_pbar=disable_pbar, seed=noise.seed) - samples = samples.to(comfy.model_management.intermediate_device()) + samples = samples.to(seap.model_management.intermediate_device()) out = latent.copy() out["samples"] = samples diff --git a/comfy_extras/nodes_differential_diffusion.py b/seap_extras/nodes_differential_diffusion.py similarity index 100% rename from comfy_extras/nodes_differential_diffusion.py rename to seap_extras/nodes_differential_diffusion.py diff --git a/comfy_extras/nodes_flux.py b/seap_extras/nodes_flux.py similarity index 100% rename from comfy_extras/nodes_flux.py rename to seap_extras/nodes_flux.py diff --git a/comfy_extras/nodes_freelunch.py b/seap_extras/nodes_freelunch.py similarity index 100% rename from comfy_extras/nodes_freelunch.py rename to seap_extras/nodes_freelunch.py diff --git a/comfy_extras/nodes_gits.py b/seap_extras/nodes_gits.py similarity index 100% rename from comfy_extras/nodes_gits.py rename to seap_extras/nodes_gits.py diff --git a/comfy_extras/nodes_hunyuan.py b/seap_extras/nodes_hunyuan.py similarity index 100% rename from comfy_extras/nodes_hunyuan.py rename to seap_extras/nodes_hunyuan.py diff --git a/comfy_extras/nodes_hypernetwork.py b/seap_extras/nodes_hypernetwork.py similarity index 98% rename from comfy_extras/nodes_hypernetwork.py rename to seap_extras/nodes_hypernetwork.py index 665632292..73ad2a329 100644 --- a/comfy_extras/nodes_hypernetwork.py +++ b/seap_extras/nodes_hypernetwork.py @@ -1,10 +1,10 @@ -import comfy.utils +import seap.utils import folder_paths import torch import logging def load_hypernetwork_patch(path, strength): - sd = comfy.utils.load_torch_file(path, safe_load=True) + sd = seap.utils.load_torch_file(path, safe_load=True) activation_func = sd.get('activation_func', 'linear') is_layer_norm = sd.get('is_layer_norm', False) use_dropout = sd.get('use_dropout', False) diff --git a/comfy_extras/nodes_hypertile.py b/seap_extras/nodes_hypertile.py similarity index 100% rename from comfy_extras/nodes_hypertile.py rename to seap_extras/nodes_hypertile.py diff --git a/comfy_extras/nodes_images.py b/seap_extras/nodes_images.py similarity index 99% rename from comfy_extras/nodes_images.py rename to seap_extras/nodes_images.py index af37666b2..6b1b8a3e5 100644 --- a/comfy_extras/nodes_images.py +++ b/seap_extras/nodes_images.py @@ -1,6 +1,6 @@ import nodes import folder_paths -from comfy.cli_args import args +from seap.cli_args import args from PIL import Image from PIL.PngImagePlugin import PngInfo diff --git a/comfy_extras/nodes_ip2p.py b/seap_extras/nodes_ip2p.py similarity index 100% rename from comfy_extras/nodes_ip2p.py rename to seap_extras/nodes_ip2p.py diff --git a/comfy_extras/nodes_latent.py b/seap_extras/nodes_latent.py similarity index 95% rename from comfy_extras/nodes_latent.py rename to seap_extras/nodes_latent.py index 1c271b827..acfec6bfd 100644 --- a/comfy_extras/nodes_latent.py +++ b/seap_extras/nodes_latent.py @@ -1,10 +1,10 @@ -import comfy.utils +import seap.utils import torch def reshape_latent_to(target_shape, latent): if latent.shape[1:] != target_shape[1:]: - latent = comfy.utils.common_upscale(latent, target_shape[3], target_shape[2], "bilinear", "center") - return comfy.utils.repeat_to_batch_size(latent, target_shape[0]) + latent = seap.utils.common_upscale(latent, target_shape[3], target_shape[2], "bilinear", "center") + return seap.utils.repeat_to_batch_size(latent, target_shape[0]) class LatentAdd: @@ -116,7 +116,7 @@ class LatentBatch: s2 = samples2["samples"] if s1.shape[1:] != s2.shape[1:]: - s2 = comfy.utils.common_upscale(s2, s1.shape[3], s1.shape[2], "bilinear", "center") + s2 = seap.utils.common_upscale(s2, s1.shape[3], s1.shape[2], "bilinear", "center") s = torch.cat((s1, s2), dim=0) samples_out["samples"] = s samples_out["batch_index"] = samples1.get("batch_index", [x for x in range(0, s1.shape[0])]) + samples2.get("batch_index", [x for x in range(0, s2.shape[0])]) diff --git a/comfy_extras/nodes_lora_extract.py b/seap_extras/nodes_lora_extract.py similarity index 95% rename from comfy_extras/nodes_lora_extract.py rename to seap_extras/nodes_lora_extract.py index 3c2f179d3..35a9f02ac 100644 --- a/comfy_extras/nodes_lora_extract.py +++ b/seap_extras/nodes_lora_extract.py @@ -1,6 +1,6 @@ import torch -import comfy.model_management -import comfy.utils +import seap.model_management +import seap.utils import folder_paths import os import logging @@ -47,7 +47,7 @@ LORA_TYPES = {"standard": LORAType.STANDARD, "full_diff": LORAType.FULL_DIFF} def calc_lora_model(model_diff, rank, prefix_model, prefix_lora, output_sd, lora_type, bias_diff=False): - comfy.model_management.load_models_gpu([model_diff], force_patch_weights=True) + seap.model_management.load_models_gpu([model_diff], force_patch_weights=True) sd = model_diff.model_state_dict(filter_prefix=prefix_model) for k in sd: @@ -107,7 +107,7 @@ class LoraSave: output_checkpoint = f"{filename}_{counter:05}_.safetensors" output_checkpoint = os.path.join(full_output_folder, output_checkpoint) - comfy.utils.save_torch_file(output_sd, output_checkpoint, metadata=None) + seap.utils.save_torch_file(output_sd, output_checkpoint, metadata=None) return {} NODE_CLASS_MAPPINGS = { diff --git a/comfy_extras/nodes_mask.py b/seap_extras/nodes_mask.py similarity index 98% rename from comfy_extras/nodes_mask.py rename to seap_extras/nodes_mask.py index 29589b4ab..1069cf9bc 100644 --- a/comfy_extras/nodes_mask.py +++ b/seap_extras/nodes_mask.py @@ -1,7 +1,7 @@ import numpy as np import scipy.ndimage import torch -import comfy.utils +import seap.utils from nodes import MAX_RESOLUTION @@ -10,7 +10,7 @@ def composite(destination, source, x, y, mask = None, multiplier = 8, resize_sou if resize_source: source = torch.nn.functional.interpolate(source, size=(destination.shape[2], destination.shape[3]), mode="bilinear") - source = comfy.utils.repeat_to_batch_size(source, destination.shape[0]) + source = seap.utils.repeat_to_batch_size(source, destination.shape[0]) x = max(-source.shape[3] * multiplier, min(x, destination.shape[3] * multiplier)) y = max(-source.shape[2] * multiplier, min(y, destination.shape[2] * multiplier)) @@ -23,7 +23,7 @@ def composite(destination, source, x, y, mask = None, multiplier = 8, resize_sou else: mask = mask.to(destination.device, copy=True) mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(source.shape[2], source.shape[3]), mode="bilinear") - mask = comfy.utils.repeat_to_batch_size(mask, source.shape[0]) + mask = seap.utils.repeat_to_batch_size(mask, source.shape[0]) # calculate the bounds of the source that will be overlapping the destination # this prevents the source trying to overwrite latent pixels that are out of bounds diff --git a/comfy_extras/nodes_model_advanced.py b/seap_extras/nodes_model_advanced.py similarity index 89% rename from comfy_extras/nodes_model_advanced.py rename to seap_extras/nodes_model_advanced.py index 918e6085a..0a9b6f841 100644 --- a/comfy_extras/nodes_model_advanced.py +++ b/seap_extras/nodes_model_advanced.py @@ -1,11 +1,11 @@ import folder_paths -import comfy.sd -import comfy.model_sampling -import comfy.latent_formats +import seap.sd +import seap.model_sampling +import seap.latent_formats import nodes import torch -class LCM(comfy.model_sampling.EPS): +class LCM(seap.model_sampling.EPS): def calculate_denoised(self, sigma, model_output, model_input): timestep = self.timestep(sigma).view(sigma.shape[:1] + (1,) * (model_output.ndim - 1)) sigma = sigma.view(sigma.shape[:1] + (1,) * (model_output.ndim - 1)) @@ -19,11 +19,11 @@ class LCM(comfy.model_sampling.EPS): return c_out * x0 + c_skip * model_input -class X0(comfy.model_sampling.EPS): +class X0(seap.model_sampling.EPS): def calculate_denoised(self, sigma, model_output, model_input): return model_output -class ModelSamplingDiscreteDistilled(comfy.model_sampling.ModelSamplingDiscrete): +class ModelSamplingDiscreteDistilled(seap.model_sampling.ModelSamplingDiscrete): original_timesteps = 50 def __init__(self, model_config=None): @@ -86,11 +86,11 @@ class ModelSamplingDiscrete: def patch(self, model, sampling, zsnr): m = model.clone() - sampling_base = comfy.model_sampling.ModelSamplingDiscrete + sampling_base = seap.model_sampling.ModelSamplingDiscrete if sampling == "eps": - sampling_type = comfy.model_sampling.EPS + sampling_type = seap.model_sampling.EPS elif sampling == "v_prediction": - sampling_type = comfy.model_sampling.V_PREDICTION + sampling_type = seap.model_sampling.V_PREDICTION elif sampling == "lcm": sampling_type = LCM sampling_base = ModelSamplingDiscreteDistilled @@ -122,8 +122,8 @@ class ModelSamplingStableCascade: def patch(self, model, shift): m = model.clone() - sampling_base = comfy.model_sampling.StableCascadeSampling - sampling_type = comfy.model_sampling.EPS + sampling_base = seap.model_sampling.StableCascadeSampling + sampling_type = seap.model_sampling.EPS class ModelSamplingAdvanced(sampling_base, sampling_type): pass @@ -148,8 +148,8 @@ class ModelSamplingSD3: def patch(self, model, shift, multiplier=1000): m = model.clone() - sampling_base = comfy.model_sampling.ModelSamplingDiscreteFlow - sampling_type = comfy.model_sampling.CONST + sampling_base = seap.model_sampling.ModelSamplingDiscreteFlow + sampling_type = seap.model_sampling.CONST class ModelSamplingAdvanced(sampling_base, sampling_type): pass @@ -195,8 +195,8 @@ class ModelSamplingFlux: b = base_shift - mm * x1 shift = (width * height / (8 * 8 * 2 * 2)) * mm + b - sampling_base = comfy.model_sampling.ModelSamplingFlux - sampling_type = comfy.model_sampling.CONST + sampling_base = seap.model_sampling.ModelSamplingFlux + sampling_type = seap.model_sampling.CONST class ModelSamplingAdvanced(sampling_base, sampling_type): pass @@ -227,15 +227,15 @@ class ModelSamplingContinuousEDM: latent_format = None sigma_data = 1.0 if sampling == "eps": - sampling_type = comfy.model_sampling.EPS + sampling_type = seap.model_sampling.EPS elif sampling == "v_prediction": - sampling_type = comfy.model_sampling.V_PREDICTION + sampling_type = seap.model_sampling.V_PREDICTION elif sampling == "edm_playground_v2.5": - sampling_type = comfy.model_sampling.EDM + sampling_type = seap.model_sampling.EDM sigma_data = 0.5 - latent_format = comfy.latent_formats.SDXL_Playground_2_5() + latent_format = seap.latent_formats.SDXL_Playground_2_5() - class ModelSamplingAdvanced(comfy.model_sampling.ModelSamplingContinuousEDM, sampling_type): + class ModelSamplingAdvanced(seap.model_sampling.ModelSamplingContinuousEDM, sampling_type): pass model_sampling = ModelSamplingAdvanced(model.model.model_config) @@ -265,9 +265,9 @@ class ModelSamplingContinuousV: latent_format = None sigma_data = 1.0 if sampling == "v_prediction": - sampling_type = comfy.model_sampling.V_PREDICTION + sampling_type = seap.model_sampling.V_PREDICTION - class ModelSamplingAdvanced(comfy.model_sampling.ModelSamplingContinuousV, sampling_type): + class ModelSamplingAdvanced(seap.model_sampling.ModelSamplingContinuousV, sampling_type): pass model_sampling = ModelSamplingAdvanced(model.model.model_config) diff --git a/comfy_extras/nodes_model_downscale.py b/seap_extras/nodes_model_downscale.py similarity index 88% rename from comfy_extras/nodes_model_downscale.py rename to seap_extras/nodes_model_downscale.py index 15ffc4c8e..fa622b927 100644 --- a/comfy_extras/nodes_model_downscale.py +++ b/seap_extras/nodes_model_downscale.py @@ -1,5 +1,5 @@ import torch -import comfy.utils +import seap.utils class PatchModelAddDownscale: upscale_methods = ["bicubic", "nearest-exact", "bilinear", "area", "bislerp"] @@ -28,12 +28,12 @@ class PatchModelAddDownscale: if transformer_options["block"][1] == block_number: sigma = transformer_options["sigmas"][0].item() if sigma <= sigma_start and sigma >= sigma_end: - h = comfy.utils.common_upscale(h, round(h.shape[-1] * (1.0 / downscale_factor)), round(h.shape[-2] * (1.0 / downscale_factor)), downscale_method, "disabled") + h = seap.utils.common_upscale(h, round(h.shape[-1] * (1.0 / downscale_factor)), round(h.shape[-2] * (1.0 / downscale_factor)), downscale_method, "disabled") return h def output_block_patch(h, hsp, transformer_options): if h.shape[2] != hsp.shape[2]: - h = comfy.utils.common_upscale(h, hsp.shape[-1], hsp.shape[-2], upscale_method, "disabled") + h = seap.utils.common_upscale(h, hsp.shape[-1], hsp.shape[-2], upscale_method, "disabled") return h, hsp m = model.clone() diff --git a/comfy_extras/nodes_model_merging.py b/seap_extras/nodes_model_merging.py similarity index 90% rename from comfy_extras/nodes_model_merging.py rename to seap_extras/nodes_model_merging.py index ccf601158..e112264ed 100644 --- a/comfy_extras/nodes_model_merging.py +++ b/seap_extras/nodes_model_merging.py @@ -1,15 +1,15 @@ -import comfy.sd -import comfy.utils -import comfy.model_base -import comfy.model_management -import comfy.model_sampling +import seap.sd +import seap.utils +import seap.model_base +import seap.model_management +import seap.model_sampling import torch import folder_paths import json import os -from comfy.cli_args import args +from seap.cli_args import args class ModelMergeSimple: @classmethod @@ -174,16 +174,16 @@ def save_checkpoint(model, clip=None, vae=None, clip_vision=None, filename_prefi metadata = {} enable_modelspec = True - if isinstance(model.model, comfy.model_base.SDXL): - if isinstance(model.model, comfy.model_base.SDXL_instructpix2pix): + if isinstance(model.model, seap.model_base.SDXL): + if isinstance(model.model, seap.model_base.SDXL_instructpix2pix): metadata["modelspec.architecture"] = "stable-diffusion-xl-v1-edit" else: metadata["modelspec.architecture"] = "stable-diffusion-xl-v1-base" - elif isinstance(model.model, comfy.model_base.SDXLRefiner): + elif isinstance(model.model, seap.model_base.SDXLRefiner): metadata["modelspec.architecture"] = "stable-diffusion-xl-v1-refiner" - elif isinstance(model.model, comfy.model_base.SVD_img2vid): + elif isinstance(model.model, seap.model_base.SVD_img2vid): metadata["modelspec.architecture"] = "stable-video-diffusion-img2vid-v1" - elif isinstance(model.model, comfy.model_base.SD3): + elif isinstance(model.model, seap.model_base.SD3): metadata["modelspec.architecture"] = "stable-diffusion-v3-medium" #TODO: other SD3 variants else: enable_modelspec = False @@ -200,14 +200,14 @@ def save_checkpoint(model, clip=None, vae=None, clip_vision=None, filename_prefi extra_keys = {} model_sampling = model.get_model_object("model_sampling") - if isinstance(model_sampling, comfy.model_sampling.ModelSamplingContinuousEDM): - if isinstance(model_sampling, comfy.model_sampling.V_PREDICTION): + if isinstance(model_sampling, seap.model_sampling.ModelSamplingContinuousEDM): + if isinstance(model_sampling, seap.model_sampling.V_PREDICTION): extra_keys["edm_vpred.sigma_max"] = torch.tensor(model_sampling.sigma_max).float() extra_keys["edm_vpred.sigma_min"] = torch.tensor(model_sampling.sigma_min).float() - if model.model.model_type == comfy.model_base.ModelType.EPS: + if model.model.model_type == seap.model_base.ModelType.EPS: metadata["modelspec.predict_key"] = "epsilon" - elif model.model.model_type == comfy.model_base.ModelType.V_PREDICTION: + elif model.model.model_type == seap.model_base.ModelType.V_PREDICTION: metadata["modelspec.predict_key"] = "v" if not args.disable_metadata: @@ -219,7 +219,7 @@ def save_checkpoint(model, clip=None, vae=None, clip_vision=None, filename_prefi output_checkpoint = f"{filename}_{counter:05}_.safetensors" output_checkpoint = os.path.join(full_output_folder, output_checkpoint) - comfy.sd.save_checkpoint(output_checkpoint, model, clip, vae, clip_vision, metadata=metadata, extra_keys=extra_keys) + seap.sd.save_checkpoint(output_checkpoint, model, clip, vae, clip_vision, metadata=metadata, extra_keys=extra_keys) class CheckpointSave: def __init__(self): @@ -270,7 +270,7 @@ class CLIPSave: for x in extra_pnginfo: metadata[x] = json.dumps(extra_pnginfo[x]) - comfy.model_management.load_models_gpu([clip.load_model()], force_patch_weights=True) + seap.model_management.load_models_gpu([clip.load_model()], force_patch_weights=True) clip_sd = clip.get_sd() for prefix in ["clip_l.", "clip_g.", ""]: @@ -294,9 +294,9 @@ class CLIPSave: output_checkpoint = f"{filename}_{counter:05}_.safetensors" output_checkpoint = os.path.join(full_output_folder, output_checkpoint) - current_clip_sd = comfy.utils.state_dict_prefix_replace(current_clip_sd, replace_prefix) + current_clip_sd = seap.utils.state_dict_prefix_replace(current_clip_sd, replace_prefix) - comfy.utils.save_torch_file(current_clip_sd, output_checkpoint, metadata=metadata) + seap.utils.save_torch_file(current_clip_sd, output_checkpoint, metadata=metadata) return {} class VAESave: @@ -330,7 +330,7 @@ class VAESave: output_checkpoint = f"{filename}_{counter:05}_.safetensors" output_checkpoint = os.path.join(full_output_folder, output_checkpoint) - comfy.utils.save_torch_file(vae.get_sd(), output_checkpoint, metadata=metadata) + seap.utils.save_torch_file(vae.get_sd(), output_checkpoint, metadata=metadata) return {} class ModelSave: diff --git a/comfy_extras/nodes_model_merging_model_specific.py b/seap_extras/nodes_model_merging_model_specific.py similarity index 91% rename from comfy_extras/nodes_model_merging_model_specific.py rename to seap_extras/nodes_model_merging_model_specific.py index 9557d9b1f..747330b02 100644 --- a/comfy_extras/nodes_model_merging_model_specific.py +++ b/seap_extras/nodes_model_merging_model_specific.py @@ -1,6 +1,6 @@ -import comfy_extras.nodes_model_merging +import seap_extras.nodes_model_merging -class ModelMergeSD1(comfy_extras.nodes_model_merging.ModelMergeBlocks): +class ModelMergeSD1(seap_extras.nodes_model_merging.ModelMergeBlocks): CATEGORY = "advanced/model_merging/model_specific" @classmethod def INPUT_TYPES(s): @@ -26,7 +26,7 @@ class ModelMergeSD1(comfy_extras.nodes_model_merging.ModelMergeBlocks): return {"required": arg_dict} -class ModelMergeSDXL(comfy_extras.nodes_model_merging.ModelMergeBlocks): +class ModelMergeSDXL(seap_extras.nodes_model_merging.ModelMergeBlocks): CATEGORY = "advanced/model_merging/model_specific" @classmethod @@ -52,7 +52,7 @@ class ModelMergeSDXL(comfy_extras.nodes_model_merging.ModelMergeBlocks): return {"required": arg_dict} -class ModelMergeSD3_2B(comfy_extras.nodes_model_merging.ModelMergeBlocks): +class ModelMergeSD3_2B(seap_extras.nodes_model_merging.ModelMergeBlocks): CATEGORY = "advanced/model_merging/model_specific" @classmethod @@ -75,7 +75,7 @@ class ModelMergeSD3_2B(comfy_extras.nodes_model_merging.ModelMergeBlocks): return {"required": arg_dict} -class ModelMergeFlux1(comfy_extras.nodes_model_merging.ModelMergeBlocks): +class ModelMergeFlux1(seap_extras.nodes_model_merging.ModelMergeBlocks): CATEGORY = "advanced/model_merging/model_specific" @classmethod diff --git a/comfy_extras/nodes_morphology.py b/seap_extras/nodes_morphology.py similarity index 90% rename from comfy_extras/nodes_morphology.py rename to seap_extras/nodes_morphology.py index 071521d87..d750fe22a 100644 --- a/comfy_extras/nodes_morphology.py +++ b/seap_extras/nodes_morphology.py @@ -1,5 +1,5 @@ import torch -import comfy.model_management +import seap.model_management from kornia.morphology import dilation, erosion, opening, closing, gradient, top_hat, bottom_hat @@ -18,7 +18,7 @@ class Morphology: CATEGORY = "image/postprocessing" def process(self, image, operation, kernel_size): - device = comfy.model_management.get_torch_device() + device = seap.model_management.get_torch_device() kernel = torch.ones(kernel_size, kernel_size, device=device) image_k = image.to(device).movedim(-1, 1) if operation == "erode": @@ -37,7 +37,7 @@ class Morphology: output = bottom_hat(image_k, kernel) else: raise ValueError(f"Invalid operation {operation} for morphology. Must be one of 'erode', 'dilate', 'open', 'close', 'gradient', 'tophat', 'bottomhat'") - img_out = output.to(comfy.model_management.intermediate_device()).movedim(1, -1) + img_out = output.to(seap.model_management.intermediate_device()).movedim(1, -1) return (img_out,) NODE_CLASS_MAPPINGS = { diff --git a/comfy_extras/nodes_pag.py b/seap_extras/nodes_pag.py similarity index 83% rename from comfy_extras/nodes_pag.py rename to seap_extras/nodes_pag.py index eb28196f4..684936bb8 100644 --- a/comfy_extras/nodes_pag.py +++ b/seap_extras/nodes_pag.py @@ -3,8 +3,8 @@ #My modified one here is more basic but has less chances of breaking with ComfyUI updates. -import comfy.model_patcher -import comfy.samplers +import seap.model_patcher +import seap.samplers class PerturbedAttentionGuidance: @classmethod @@ -42,8 +42,8 @@ class PerturbedAttentionGuidance: return cfg_result # Replace Self-attention with PAG - model_options = comfy.model_patcher.set_model_options_patch_replace(model_options, perturbed_attention, "attn1", unet_block, unet_block_id) - (pag,) = comfy.samplers.calc_cond_batch(model, [cond], x, sigma, model_options) + model_options = seap.model_patcher.set_model_options_patch_replace(model_options, perturbed_attention, "attn1", unet_block, unet_block_id) + (pag,) = seap.samplers.calc_cond_batch(model, [cond], x, sigma, model_options) return cfg_result + (cond_pred - pag) * scale diff --git a/comfy_extras/nodes_perpneg.py b/seap_extras/nodes_perpneg.py similarity index 88% rename from comfy_extras/nodes_perpneg.py rename to seap_extras/nodes_perpneg.py index 762c40220..026f11c17 100644 --- a/comfy_extras/nodes_perpneg.py +++ b/seap_extras/nodes_perpneg.py @@ -1,8 +1,8 @@ import torch -import comfy.model_management -import comfy.sampler_helpers -import comfy.samplers -import comfy.utils +import seap.model_management +import seap.sampler_helpers +import seap.samplers +import seap.utils import node_helpers def perp_neg(x, noise_pred_pos, noise_pred_neg, noise_pred_nocond, neg_scale, cond_scale): @@ -30,7 +30,7 @@ class PerpNeg: def patch(self, model, empty_conditioning, neg_scale): m = model.clone() - nocond = comfy.sampler_helpers.convert_cond(empty_conditioning) + nocond = seap.sampler_helpers.convert_cond(empty_conditioning) def cfg_function(args): model = args["model"] @@ -40,9 +40,9 @@ class PerpNeg: x = args["input"] sigma = args["sigma"] model_options = args["model_options"] - nocond_processed = comfy.samplers.encode_model_conds(model.extra_conds, nocond, x, x.device, "negative") + nocond_processed = seap.samplers.encode_model_conds(model.extra_conds, nocond, x, x.device, "negative") - (noise_pred_nocond,) = comfy.samplers.calc_cond_batch(model, [nocond_processed], x, sigma, model_options) + (noise_pred_nocond,) = seap.samplers.calc_cond_batch(model, [nocond_processed], x, sigma, model_options) cfg_result = x - perp_neg(x, noise_pred_pos, noise_pred_neg, noise_pred_nocond, neg_scale, cond_scale) return cfg_result @@ -52,7 +52,7 @@ class PerpNeg: return (m, ) -class Guider_PerpNeg(comfy.samplers.CFGGuider): +class Guider_PerpNeg(seap.samplers.CFGGuider): def set_conds(self, positive, negative, empty_negative_prompt): empty_negative_prompt = node_helpers.conditioning_set_values(empty_negative_prompt, {"prompt_type": "negative"}) self.inner_set_conds({"positive": positive, "empty_negative_prompt": empty_negative_prompt, "negative": negative}) @@ -70,7 +70,7 @@ class Guider_PerpNeg(comfy.samplers.CFGGuider): empty_cond = self.conds.get("empty_negative_prompt", None) (noise_pred_pos, noise_pred_neg, noise_pred_empty) = \ - comfy.samplers.calc_cond_batch(self.inner_model, [positive_cond, negative_cond, empty_cond], x, timestep, model_options) + seap.samplers.calc_cond_batch(self.inner_model, [positive_cond, negative_cond, empty_cond], x, timestep, model_options) cfg_result = perp_neg(x, noise_pred_pos, noise_pred_neg, noise_pred_empty, self.neg_scale, self.cfg) # normally this would be done in cfg_function, but we skipped diff --git a/comfy_extras/nodes_photomaker.py b/seap_extras/nodes_photomaker.py similarity index 89% rename from comfy_extras/nodes_photomaker.py rename to seap_extras/nodes_photomaker.py index 95d24dd22..53a9016bb 100644 --- a/comfy_extras/nodes_photomaker.py +++ b/seap_extras/nodes_photomaker.py @@ -1,9 +1,9 @@ import torch import torch.nn as nn import folder_paths -import comfy.clip_model -import comfy.clip_vision -import comfy.ops +import seap.clip_model +import seap.clip_vision +import seap.ops # code for model from: https://github.com/TencentARC/PhotoMaker/blob/main/photomaker/model.py under Apache License Version 2.0 VISION_CONFIG_DICT = { @@ -19,7 +19,7 @@ VISION_CONFIG_DICT = { } class MLP(nn.Module): - def __init__(self, in_dim, out_dim, hidden_dim, use_residual=True, operations=comfy.ops): + def __init__(self, in_dim, out_dim, hidden_dim, use_residual=True, operations=seap.ops): super().__init__() if use_residual: assert in_dim == out_dim @@ -88,15 +88,15 @@ class FuseModule(nn.Module): updated_prompt_embeds = prompt_embeds.view(batch_size, seq_length, -1) return updated_prompt_embeds -class PhotoMakerIDEncoder(comfy.clip_model.CLIPVisionModelProjection): +class PhotoMakerIDEncoder(seap.clip_model.CLIPVisionModelProjection): def __init__(self): - self.load_device = comfy.model_management.text_encoder_device() - offload_device = comfy.model_management.text_encoder_offload_device() - dtype = comfy.model_management.text_encoder_dtype(self.load_device) + self.load_device = seap.model_management.text_encoder_device() + offload_device = seap.model_management.text_encoder_offload_device() + dtype = seap.model_management.text_encoder_dtype(self.load_device) - super().__init__(VISION_CONFIG_DICT, dtype, offload_device, comfy.ops.manual_cast) - self.visual_projection_2 = comfy.ops.manual_cast.Linear(1024, 1280, bias=False) - self.fuse_module = FuseModule(2048, comfy.ops.manual_cast) + super().__init__(VISION_CONFIG_DICT, dtype, offload_device, seap.ops.manual_cast) + self.visual_projection_2 = seap.ops.manual_cast.Linear(1024, 1280, bias=False) + self.fuse_module = FuseModule(2048, seap.ops.manual_cast) def forward(self, id_pixel_values, prompt_embeds, class_tokens_mask): b, num_inputs, c, h, w = id_pixel_values.shape @@ -128,7 +128,7 @@ class PhotoMakerLoader: def load_photomaker_model(self, photomaker_model_name): photomaker_model_path = folder_paths.get_full_path_or_raise("photomaker", photomaker_model_name) photomaker_model = PhotoMakerIDEncoder() - data = comfy.utils.load_torch_file(photomaker_model_path, safe_load=True) + data = seap.utils.load_torch_file(photomaker_model_path, safe_load=True) if "id_encoder" in data: data = data["id_encoder"] photomaker_model.load_state_dict(data) @@ -151,7 +151,7 @@ class PhotoMakerEncode: def apply_photomaker(self, photomaker, image, clip, text): special_token = "photomaker" - pixel_values = comfy.clip_vision.clip_preprocess(image.to(photomaker.load_device)).float() + pixel_values = seap.clip_vision.clip_preprocess(image.to(photomaker.load_device)).float() try: index = text.split(" ").index(special_token) + 1 except ValueError: diff --git a/comfy_extras/nodes_post_processing.py b/seap_extras/nodes_post_processing.py similarity index 94% rename from comfy_extras/nodes_post_processing.py rename to seap_extras/nodes_post_processing.py index 68f6ef51e..ac691d32a 100644 --- a/comfy_extras/nodes_post_processing.py +++ b/seap_extras/nodes_post_processing.py @@ -4,8 +4,8 @@ import torch.nn.functional as F from PIL import Image import math -import comfy.utils -import comfy.model_management +import seap.utils +import seap.model_management class Blend: @@ -37,7 +37,7 @@ class Blend: image2 = image2.to(image1.device) if image1.shape != image2.shape: image2 = image2.permute(0, 3, 1, 2) - image2 = comfy.utils.common_upscale(image2, image1.shape[2], image1.shape[1], upscale_method='bicubic', crop='center') + image2 = seap.utils.common_upscale(image2, image1.shape[2], image1.shape[1], upscale_method='bicubic', crop='center') image2 = image2.permute(0, 2, 3, 1) blended_image = self.blend_mode(image1, image2, blend_mode) @@ -103,7 +103,7 @@ class Blur: if blur_radius == 0: return (image,) - image = image.to(comfy.model_management.get_torch_device()) + image = image.to(seap.model_management.get_torch_device()) batch_size, height, width, channels = image.shape kernel_size = blur_radius * 2 + 1 @@ -114,7 +114,7 @@ class Blur: blurred = F.conv2d(padded_image, kernel, padding=kernel_size // 2, groups=channels)[:,:,blur_radius:-blur_radius, blur_radius:-blur_radius] blurred = blurred.permute(0, 2, 3, 1) - return (blurred.to(comfy.model_management.intermediate_device()),) + return (blurred.to(seap.model_management.intermediate_device()),) class Quantize: def __init__(self): @@ -227,7 +227,7 @@ class Sharpen: return (image,) batch_size, height, width, channels = image.shape - image = image.to(comfy.model_management.get_torch_device()) + image = image.to(seap.model_management.get_torch_device()) kernel_size = sharpen_radius * 2 + 1 kernel = gaussian_kernel(kernel_size, sigma, device=image.device) * -(alpha*10) @@ -242,7 +242,7 @@ class Sharpen: result = torch.clamp(sharpened, 0, 1) - return (result.to(comfy.model_management.intermediate_device()),) + return (result.to(seap.model_management.intermediate_device()),) class ImageScaleToTotalPixels: upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "lanczos"] @@ -266,7 +266,7 @@ class ImageScaleToTotalPixels: width = round(samples.shape[3] * scale_by) height = round(samples.shape[2] * scale_by) - s = comfy.utils.common_upscale(samples, width, height, upscale_method, "disabled") + s = seap.utils.common_upscale(samples, width, height, upscale_method, "disabled") s = s.movedim(1,-1) return (s,) diff --git a/comfy_extras/nodes_rebatch.py b/seap_extras/nodes_rebatch.py similarity index 100% rename from comfy_extras/nodes_rebatch.py rename to seap_extras/nodes_rebatch.py diff --git a/comfy_extras/nodes_sag.py b/seap_extras/nodes_sag.py similarity index 96% rename from comfy_extras/nodes_sag.py rename to seap_extras/nodes_sag.py index 5e15b99e5..884cf7cc2 100644 --- a/comfy_extras/nodes_sag.py +++ b/seap_extras/nodes_sag.py @@ -4,10 +4,10 @@ import torch.nn.functional as F import math from einops import rearrange, repeat -from comfy.ldm.modules.attention import optimized_attention -import comfy.samplers +from seap.ldm.modules.attention import optimized_attention +import seap.samplers -# from comfy/ldm/modules/attention.py +# from seap/ldm/modules/attention.py # but modified to return attention scores as well as output def attention_basic_with_sim(q, k, v, heads, mask=None, attn_precision=None): b, _, dim_head = q.shape @@ -149,7 +149,7 @@ class SelfAttentionGuidance: degraded = create_blur_map(uncond_pred, uncond_attn, sag_sigma, sag_threshold) degraded_noised = degraded + x - uncond_pred # call into the UNet - (sag,) = comfy.samplers.calc_cond_batch(model, [uncond], degraded_noised, sigma, model_options) + (sag,) = seap.samplers.calc_cond_batch(model, [uncond], degraded_noised, sigma, model_options) return cfg_result + (degraded - sag) * sag_scale m.set_model_sampler_post_cfg_function(post_cfg_function, disable_cfg1_optimization=True) diff --git a/comfy_extras/nodes_sd3.py b/seap_extras/nodes_sd3.py similarity index 93% rename from comfy_extras/nodes_sd3.py rename to seap_extras/nodes_sd3.py index ddf538deb..fba160649 100644 --- a/comfy_extras/nodes_sd3.py +++ b/seap_extras/nodes_sd3.py @@ -1,6 +1,6 @@ import folder_paths -import comfy.sd -import comfy.model_management +import seap.sd +import seap.model_management import nodes import torch @@ -18,12 +18,12 @@ class TripleCLIPLoader: clip_path1 = folder_paths.get_full_path_or_raise("clip", clip_name1) clip_path2 = folder_paths.get_full_path_or_raise("clip", clip_name2) clip_path3 = folder_paths.get_full_path_or_raise("clip", clip_name3) - clip = comfy.sd.load_clip(ckpt_paths=[clip_path1, clip_path2, clip_path3], embedding_directory=folder_paths.get_folder_paths("embeddings")) + clip = seap.sd.load_clip(ckpt_paths=[clip_path1, clip_path2, clip_path3], embedding_directory=folder_paths.get_folder_paths("embeddings")) return (clip,) class EmptySD3LatentImage: def __init__(self): - self.device = comfy.model_management.intermediate_device() + self.device = seap.model_management.intermediate_device() @classmethod def INPUT_TYPES(s): diff --git a/comfy_extras/nodes_sdupscale.py b/seap_extras/nodes_sdupscale.py similarity index 95% rename from comfy_extras/nodes_sdupscale.py rename to seap_extras/nodes_sdupscale.py index bba67e8dd..0ad6eb596 100644 --- a/comfy_extras/nodes_sdupscale.py +++ b/seap_extras/nodes_sdupscale.py @@ -1,5 +1,5 @@ import torch -import comfy.utils +import seap.utils class SD_4XUpscale_Conditioning: @classmethod @@ -21,7 +21,7 @@ class SD_4XUpscale_Conditioning: width = max(1, round(images.shape[-2] * scale_ratio)) height = max(1, round(images.shape[-3] * scale_ratio)) - pixels = comfy.utils.common_upscale((images.movedim(-1,1) * 2.0) - 1.0, width // 4, height // 4, "bilinear", "center") + pixels = seap.utils.common_upscale((images.movedim(-1, 1) * 2.0) - 1.0, width // 4, height // 4, "bilinear", "center") out_cp = [] out_cn = [] diff --git a/comfy_extras/nodes_stable3d.py b/seap_extras/nodes_stable3d.py similarity index 93% rename from comfy_extras/nodes_stable3d.py rename to seap_extras/nodes_stable3d.py index be2e34c28..e3ccf7366 100644 --- a/comfy_extras/nodes_stable3d.py +++ b/seap_extras/nodes_stable3d.py @@ -1,6 +1,6 @@ import torch import nodes -import comfy.utils +import seap.utils def camera_embeddings(elevation, azimuth): elevation = torch.as_tensor([elevation]) @@ -42,7 +42,7 @@ class StableZero123_Conditioning: def encode(self, clip_vision, init_image, vae, width, height, batch_size, elevation, azimuth): output = clip_vision.encode_image(init_image) pooled = output.image_embeds.unsqueeze(0) - pixels = comfy.utils.common_upscale(init_image.movedim(-1,1), width, height, "bilinear", "center").movedim(1,-1) + pixels = seap.utils.common_upscale(init_image.movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1) encode_pixels = pixels[:,:,:,:3] t = vae.encode(encode_pixels) cam_embeds = camera_embeddings(elevation, azimuth) @@ -77,7 +77,7 @@ class StableZero123_Conditioning_Batched: def encode(self, clip_vision, init_image, vae, width, height, batch_size, elevation, azimuth, elevation_batch_increment, azimuth_batch_increment): output = clip_vision.encode_image(init_image) pooled = output.image_embeds.unsqueeze(0) - pixels = comfy.utils.common_upscale(init_image.movedim(-1,1), width, height, "bilinear", "center").movedim(1,-1) + pixels = seap.utils.common_upscale(init_image.movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1) encode_pixels = pixels[:,:,:,:3] t = vae.encode(encode_pixels) @@ -88,7 +88,7 @@ class StableZero123_Conditioning_Batched: azimuth += azimuth_batch_increment cam_embeds = torch.cat(cam_embeds, dim=0) - cond = torch.cat([comfy.utils.repeat_to_batch_size(pooled, batch_size), cam_embeds], dim=-1) + cond = torch.cat([seap.utils.repeat_to_batch_size(pooled, batch_size), cam_embeds], dim=-1) positive = [[cond, {"concat_latent_image": t}]] negative = [[torch.zeros_like(pooled), {"concat_latent_image": torch.zeros_like(t)}]] @@ -116,7 +116,7 @@ class SV3D_Conditioning: def encode(self, clip_vision, init_image, vae, width, height, video_frames, elevation): output = clip_vision.encode_image(init_image) pooled = output.image_embeds.unsqueeze(0) - pixels = comfy.utils.common_upscale(init_image.movedim(-1,1), width, height, "bilinear", "center").movedim(1,-1) + pixels = seap.utils.common_upscale(init_image.movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1) encode_pixels = pixels[:,:,:,:3] t = vae.encode(encode_pixels) diff --git a/comfy_extras/nodes_stable_cascade.py b/seap_extras/nodes_stable_cascade.py similarity index 97% rename from comfy_extras/nodes_stable_cascade.py rename to seap_extras/nodes_stable_cascade.py index 003403215..bfc24d6c1 100644 --- a/comfy_extras/nodes_stable_cascade.py +++ b/seap_extras/nodes_stable_cascade.py @@ -18,7 +18,7 @@ import torch import nodes -import comfy.utils +import seap.utils class StableCascade_EmptyLatentImage: @@ -71,7 +71,7 @@ class StableCascade_StageC_VAEEncode: out_width = (width // compression) * vae.downscale_ratio out_height = (height // compression) * vae.downscale_ratio - s = comfy.utils.common_upscale(image.movedim(-1,1), out_width, out_height, "bicubic", "center").movedim(1,-1) + s = seap.utils.common_upscale(image.movedim(-1, 1), out_width, out_height, "bicubic", "center").movedim(1, -1) c_latent = vae.encode(s[:,:,:,:3]) b_latent = torch.zeros([c_latent.shape[0], 4, (height // 8) * 2, (width // 8) * 2]) diff --git a/comfy_extras/nodes_tomesd.py b/seap_extras/nodes_tomesd.py similarity index 100% rename from comfy_extras/nodes_tomesd.py rename to seap_extras/nodes_tomesd.py diff --git a/comfy_extras/nodes_torch_compile.py b/seap_extras/nodes_torch_compile.py similarity index 100% rename from comfy_extras/nodes_torch_compile.py rename to seap_extras/nodes_torch_compile.py diff --git a/comfy_extras/nodes_upscale_model.py b/seap_extras/nodes_upscale_model.py similarity index 81% rename from comfy_extras/nodes_upscale_model.py rename to seap_extras/nodes_upscale_model.py index 6ba3e404f..df85ea62e 100644 --- a/comfy_extras/nodes_upscale_model.py +++ b/seap_extras/nodes_upscale_model.py @@ -1,9 +1,9 @@ import os import logging from spandrel import ModelLoader, ImageModelDescriptor -from comfy import model_management +from seap import model_management import torch -import comfy.utils +import seap.utils import folder_paths try: @@ -26,9 +26,9 @@ class UpscaleModelLoader: def load_model(self, model_name): model_path = folder_paths.get_full_path_or_raise("upscale_models", model_name) - sd = comfy.utils.load_torch_file(model_path, safe_load=True) + sd = seap.utils.load_torch_file(model_path, safe_load=True) if "module.layers.0.residual_group.blocks.0.norm1.weight" in sd: - sd = comfy.utils.state_dict_prefix_replace(sd, {"module.":""}) + sd = seap.utils.state_dict_prefix_replace(sd, {"module.": ""}) out = ModelLoader().load_from_state_dict(sd).eval() if not isinstance(out, ImageModelDescriptor): @@ -65,9 +65,9 @@ class ImageUpscaleWithModel: oom = True while oom: try: - steps = in_img.shape[0] * comfy.utils.get_tiled_scale_steps(in_img.shape[3], in_img.shape[2], tile_x=tile, tile_y=tile, overlap=overlap) - pbar = comfy.utils.ProgressBar(steps) - s = comfy.utils.tiled_scale(in_img, lambda a: upscale_model(a), tile_x=tile, tile_y=tile, overlap=overlap, upscale_amount=upscale_model.scale, pbar=pbar) + steps = in_img.shape[0] * seap.utils.get_tiled_scale_steps(in_img.shape[3], in_img.shape[2], tile_x=tile, tile_y=tile, overlap=overlap) + pbar = seap.utils.ProgressBar(steps) + s = seap.utils.tiled_scale(in_img, lambda a: upscale_model(a), tile_x=tile, tile_y=tile, overlap=overlap, upscale_amount=upscale_model.scale, pbar=pbar) oom = False except model_management.OOM_EXCEPTION as e: tile //= 2 diff --git a/comfy_extras/nodes_video_model.py b/seap_extras/nodes_video_model.py similarity index 88% rename from comfy_extras/nodes_video_model.py rename to seap_extras/nodes_video_model.py index e7a7ec181..9b529312e 100644 --- a/comfy_extras/nodes_video_model.py +++ b/seap_extras/nodes_video_model.py @@ -1,9 +1,9 @@ import nodes import torch -import comfy.utils -import comfy.sd +import seap.utils +import seap.sd import folder_paths -import comfy_extras.nodes_model_merging +import seap_extras.nodes_model_merging class ImageOnlyCheckpointLoader: @@ -18,7 +18,7 @@ class ImageOnlyCheckpointLoader: def load_checkpoint(self, ckpt_name, output_vae=True, output_clip=True): ckpt_path = folder_paths.get_full_path_or_raise("checkpoints", ckpt_name) - out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=False, output_clipvision=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) + out = seap.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=False, output_clipvision=True, embedding_directory=folder_paths.get_folder_paths("embeddings")) return (out[0], out[3], out[2]) @@ -45,7 +45,7 @@ class SVD_img2vid_Conditioning: def encode(self, clip_vision, init_image, vae, width, height, video_frames, motion_bucket_id, fps, augmentation_level): output = clip_vision.encode_image(init_image) pooled = output.image_embeds.unsqueeze(0) - pixels = comfy.utils.common_upscale(init_image.movedim(-1,1), width, height, "bilinear", "center").movedim(1,-1) + pixels = seap.utils.common_upscale(init_image.movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1) encode_pixels = pixels[:,:,:,:3] if augmentation_level > 0: encode_pixels += torch.randn_like(pixels) * augmentation_level @@ -106,7 +106,7 @@ class VideoTriangleCFGGuidance: m.set_model_sampler_cfg_function(linear_cfg) return (m, ) -class ImageOnlyCheckpointSave(comfy_extras.nodes_model_merging.CheckpointSave): +class ImageOnlyCheckpointSave(seap_extras.nodes_model_merging.CheckpointSave): CATEGORY = "advanced/model_merging" @classmethod @@ -118,7 +118,7 @@ class ImageOnlyCheckpointSave(comfy_extras.nodes_model_merging.CheckpointSave): "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},} def save(self, model, clip_vision, vae, filename_prefix, prompt=None, extra_pnginfo=None): - comfy_extras.nodes_model_merging.save_checkpoint(model, clip_vision=clip_vision, vae=vae, filename_prefix=filename_prefix, output_dir=self.output_dir, prompt=prompt, extra_pnginfo=extra_pnginfo) + seap_extras.nodes_model_merging.save_checkpoint(model, clip_vision=clip_vision, vae=vae, filename_prefix=filename_prefix, output_dir=self.output_dir, prompt=prompt, extra_pnginfo=extra_pnginfo) return {} NODE_CLASS_MAPPINGS = { diff --git a/comfy_extras/nodes_webcam.py b/seap_extras/nodes_webcam.py similarity index 100% rename from comfy_extras/nodes_webcam.py rename to seap_extras/nodes_webcam.py diff --git a/server.py b/server.py index c7bf6622d..e72cc02d7 100644 --- a/server.py +++ b/server.py @@ -23,9 +23,9 @@ from aiohttp import web import logging import mimetypes -from comfy.cli_args import args -import comfy.utils -import comfy.model_management +from seap.cli_args import args +import seap.utils +import seap.model_management import node_helpers from app.frontend_management import FrontendManager from app.user_manager import UserManager @@ -111,7 +111,7 @@ def is_loopback(host): def create_origin_only_middleware(): @web.middleware async def origin_only_middleware(request: web.Request, handler): - #this code is used to prevent the case where a random website can queue comfy workflows by making a POST to 127.0.0.1 which browsers don't prevent for some dumb reason. + #this code is used to prevent the case where a random website can queue seap workflows by making a POST to 127.0.0.1 which browsers don't prevent for some dumb reason. #in that case the Host and Origin hostnames won't match #I know the proper fix would be to add a cookie but this should take care of the problem in the meantime if 'Host' in request.headers and 'Origin' in request.headers: @@ -478,7 +478,7 @@ class PromptServer(): safetensors_path = folder_paths.get_full_path(folder_name, filename) if safetensors_path is None: return web.Response(status=404) - out = comfy.utils.safetensors_header(safetensors_path, max_size=1024*1024) + out = seap.utils.safetensors_header(safetensors_path, max_size=1024 * 1024) if out is None: return web.Response(status=404) dt = json.loads(out) @@ -488,13 +488,13 @@ class PromptServer(): @routes.get("/system_stats") async def system_stats(request): - device = comfy.model_management.get_torch_device() - device_name = comfy.model_management.get_torch_device_name(device) - cpu_device = comfy.model_management.torch.device("cpu") - ram_total = comfy.model_management.get_total_memory(cpu_device) - ram_free = comfy.model_management.get_free_memory(cpu_device) - vram_total, torch_vram_total = comfy.model_management.get_total_memory(device, torch_total_too=True) - vram_free, torch_vram_free = comfy.model_management.get_free_memory(device, torch_free_too=True) + device = seap.model_management.get_torch_device() + device_name = seap.model_management.get_torch_device_name(device) + cpu_device = seap.model_management.torch.device("cpu") + ram_total = seap.model_management.get_total_memory(cpu_device) + ram_free = seap.model_management.get_free_memory(cpu_device) + vram_total, torch_vram_total = seap.model_management.get_total_memory(device, torch_total_too=True) + vram_free, torch_vram_free = seap.model_management.get_free_memory(device, torch_free_too=True) system_stats = { "system": { @@ -503,7 +503,7 @@ class PromptServer(): "ram_free": ram_free, "comfyui_version": get_comfyui_version(), "python_version": sys.version, - "pytorch_version": comfy.model_management.torch_version, + "pytorch_version": seap.model_management.torch_version, "embedded_python": os.path.split(os.path.split(sys.executable)[0])[1] == "python_embeded", "argv": sys.argv }, diff --git a/tests-unit/app_test/frontend_manager_test.py b/tests-unit/app_test/frontend_manager_test.py index a8df52484..f9c34a160 100644 --- a/tests-unit/app_test/frontend_manager_test.py +++ b/tests-unit/app_test/frontend_manager_test.py @@ -8,7 +8,7 @@ from app.frontend_management import ( FrontEndProvider, Release, ) -from comfy.cli_args import DEFAULT_VERSION_STRING +from seap.cli_args import DEFAULT_VERSION_STRING @pytest.fixture diff --git a/tests/inference/test_execution.py b/tests/inference/test_execution.py index 3909ca68d..d08425014 100644 --- a/tests/inference/test_execution.py +++ b/tests/inference/test_execution.py @@ -13,7 +13,7 @@ import uuid import urllib.request import urllib.parse import urllib.error -from comfy_execution.graph_utils import GraphBuilder, Node +from seap_execution.graph_utils import GraphBuilder, Node class RunResult: def __init__(self, prompt_id: str): diff --git a/tests/inference/test_inference.py b/tests/inference/test_inference.py index 2e11778f2..872ac160d 100644 --- a/tests/inference/test_inference.py +++ b/tests/inference/test_inference.py @@ -17,7 +17,7 @@ import urllib.request import urllib.parse -from comfy.samplers import KSampler +from seap.samplers import KSampler """ These tests generate and save images through a range of parameters @@ -220,7 +220,7 @@ class TestInference: ): test_info = request.node.name comfy_graph.set_filename_prefix(test_info) - # Settings for comfy graph + # Settings for seap graph comfy_graph.set_sampler_name(sampler) comfy_graph.set_scheduler(scheduler) comfy_graph.set_prompt(prompt) diff --git a/tests/inference/testing_nodes/testing-pack/flow_control.py b/tests/inference/testing_nodes/testing-pack/flow_control.py index ba943be60..d489b45a2 100644 --- a/tests/inference/testing_nodes/testing-pack/flow_control.py +++ b/tests/inference/testing_nodes/testing-pack/flow_control.py @@ -1,5 +1,5 @@ -from comfy_execution.graph_utils import GraphBuilder, is_link -from comfy_execution.graph import ExecutionBlocker +from seap_execution.graph_utils import GraphBuilder, is_link +from seap_execution.graph import ExecutionBlocker from .tools import VariantSupport NUM_FLOW_SOCKETS = 5 diff --git a/tests/inference/testing_nodes/testing-pack/specific_tests.py b/tests/inference/testing_nodes/testing-pack/specific_tests.py index dd8100237..a8da9231e 100644 --- a/tests/inference/testing_nodes/testing-pack/specific_tests.py +++ b/tests/inference/testing_nodes/testing-pack/specific_tests.py @@ -1,6 +1,6 @@ import torch from .tools import VariantSupport -from comfy_execution.graph_utils import GraphBuilder +from seap_execution.graph_utils import GraphBuilder class TestLazyMixImages: @classmethod diff --git a/tests/inference/testing_nodes/testing-pack/util.py b/tests/inference/testing_nodes/testing-pack/util.py index ca116c16e..46f5a251e 100644 --- a/tests/inference/testing_nodes/testing-pack/util.py +++ b/tests/inference/testing_nodes/testing-pack/util.py @@ -1,4 +1,4 @@ -from comfy_execution.graph_utils import GraphBuilder +from seap_execution.graph_utils import GraphBuilder from .tools import VariantSupport @VariantSupport() diff --git a/web/assets/GraphView-CVV2XJjS.js b/web/assets/GraphView-CVV2XJjS.js index 1d43b2f6a..bfc30559f 100644 --- a/web/assets/GraphView-CVV2XJjS.js +++ b/web/assets/GraphView-CVV2XJjS.js @@ -316,7 +316,7 @@ const _sfc_main$F = /* @__PURE__ */ defineComponent({ icon: icon.value, onClick: toggleTheme, tooltip: _ctx.$t("sideToolbar.themeToggle"), - class: "comfy-vue-theme-toggle" + class: "seap-vue-theme-toggle" }, null, 8, ["icon", "tooltip"]); }; } @@ -334,7 +334,7 @@ const _sfc_main$E = /* @__PURE__ */ defineComponent({ return (_ctx, _cache) => { return openBlock(), createBlock(SidebarIcon, { icon: "pi pi-cog", - class: "comfy-settings-btn", + class: "seap-settings-btn", onClick: showSetting, tooltip: _ctx.$t("settings") }, null, 8, ["tooltip"]); @@ -3316,10 +3316,10 @@ const _sfc_main$y = /* @__PURE__ */ defineComponent({ }); const NodePreview = /* @__PURE__ */ _export_sfc(_sfc_main$y, [["__scopeId", "data-v-ff07c900"]]); const _withScopeId$g = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-2d409367"), n = n(), popScopeId(), n), "_withScopeId$g"); -const _hoisted_1$w = { class: "comfy-vue-node-search-container" }; +const _hoisted_1$w = { class: "seap-vue-node-search-container" }; const _hoisted_2$o = { key: 0, - class: "comfy-vue-node-preview-container" + class: "seap-vue-node-preview-container" }; const _hoisted_3$i = /* @__PURE__ */ _withScopeId$g(() => /* @__PURE__ */ createBaseVNode("h3", null, "Add node filter condition", -1)); const _hoisted_4$b = { class: "_dialog-body" }; @@ -3415,7 +3415,7 @@ const _sfc_main$x = /* @__PURE__ */ defineComponent({ }, 8, ["visible"]), createVNode(_sfc_main$B, { "model-value": props.filters, - class: "comfy-vue-node-search-box", + class: "seap-vue-node-search-box", scrollHeight: "40vh", placeholder: placeholder.value, "input-id": inputId, @@ -5804,7 +5804,7 @@ const _sfc_main$t = /* @__PURE__ */ defineComponent({ }); watchEffect(() => { const spellcheckEnabled = settingStore.get("Comfy.TextareaWidget.Spellcheck"); - const textareas = document.querySelectorAll("textarea.comfy-multiline-input"); + const textareas = document.querySelectorAll("textarea.seap-multiline-input"); textareas.forEach((textarea) => { textarea.spellcheck = spellcheckEnabled; textarea.focus(); @@ -7344,20 +7344,20 @@ const _sfc_main$s = /* @__PURE__ */ defineComponent({ return openBlock(), createElementBlock(Fragment, null, [ !imageBroken.value ? (openBlock(), createElementBlock("span", { key: 0, - class: normalizeClass(["comfy-image-wrap", [{ contain: _ctx.contain }]]) + class: normalizeClass(["seap-image-wrap", [{ contain: _ctx.contain }]]) }, [ _ctx.contain ? (openBlock(), createElementBlock("img", { key: 0, src: _ctx.src, onError: handleImageError, "data-test": _ctx.src, - class: "comfy-image-blur", + class: "seap-image-blur", style: normalizeStyle({ "background-image": `url(${_ctx.src})` }) }, null, 44, _hoisted_1$r)) : createCommentVNode("", true), createBaseVNode("img", { src: _ctx.src, onError: handleImageError, - class: normalizeClass(["comfy-image-main", [...classArray.value]]) + class: normalizeClass(["seap-image-main", [...classArray.value]]) }, null, 42, _hoisted_2$k) ], 2)) : createCommentVNode("", true), imageBroken.value ? (openBlock(), createElementBlock("div", _hoisted_3$e, [ @@ -9287,9 +9287,9 @@ function render$9(_ctx, _cache, $props, $setup, $data, $options) { __name(render$9, "render$9"); script$a.render = render$9; const _withScopeId$c = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-1b0a8fe3"), n = n(), popScopeId(), n), "_withScopeId$c"); -const _hoisted_1$l = { class: "comfy-vue-side-bar-container" }; -const _hoisted_2$f = { class: "comfy-vue-side-bar-header-span" }; -const _hoisted_3$a = { class: "comfy-vue-side-bar-body" }; +const _hoisted_1$l = { class: "seap-vue-side-bar-container" }; +const _hoisted_2$f = { class: "seap-vue-side-bar-header-span" }; +const _hoisted_3$a = { class: "seap-vue-side-bar-body" }; const _sfc_main$o = /* @__PURE__ */ defineComponent({ __name: "SidebarTabTemplate", props: { @@ -9302,7 +9302,7 @@ const _sfc_main$o = /* @__PURE__ */ defineComponent({ const props = __props; return (_ctx, _cache) => { return openBlock(), createElementBlock("div", _hoisted_1$l, [ - createVNode(unref(script$a), { class: "comfy-vue-side-bar-header" }, { + createVNode(unref(script$a), { class: "seap-vue-side-bar-header" }, { start: withCtx(() => [ createBaseVNode("span", _hoisted_2$f, toDisplayString(props.title.toUpperCase()), 1) ]), @@ -17332,14 +17332,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({ watchEffect(() => { const fontSize = settingStore.get("Comfy.TextareaWidget.FontSize"); document.documentElement.style.setProperty( - "--comfy-textarea-font-size", + "--seap-textarea-font-size", `${fontSize}px` ); }); watchEffect(() => { const padding = settingStore.get("Comfy.TreeExplorer.ItemPadding"); document.documentElement.style.setProperty( - "--comfy-tree-explorer-item-padding", + "--seap-tree-explorer-item-padding", `${padding}px` ); }); diff --git a/web/assets/index-BMC1ey-i.js b/web/assets/index-BMC1ey-i.js index 10316d179..1be555745 100644 --- a/web/assets/index-BMC1ey-i.js +++ b/web/assets/index-BMC1ey-i.js @@ -33,7 +33,7 @@ class ClipspaceDialog extends ComfyDialog { static invalidate() { if (ClipspaceDialog.instance) { const self = ClipspaceDialog.instance; - const children = $el("div.comfy-modal-content", [ + const children = $el("div.seap-modal-content", [ self.createImgSettings(), ...self.createButtons() ]); @@ -41,7 +41,7 @@ class ClipspaceDialog extends ComfyDialog { self.element.removeChild(self.element.firstChild); self.element.appendChild(children); } else { - self.element = $el("div.comfy-modal", { parent: document.body }, [ + self.element = $el("div.seap-modal", { parent: document.body }, [ children ]); } @@ -163,7 +163,7 @@ const ext$2 = { const ctx = new ctxMenu(values, options); if (options?.className === "dark" && values?.length > 4) { const filter = document.createElement("input"); - filter.classList.add("comfy-context-menu-filter"); + filter.classList.add("seap-context-menu-filter"); filter.placeholder = "Filter list"; ctx.root.prepend(filter); const items = Array.from( @@ -469,7 +469,7 @@ class ManageGroupDialog extends ComfyDialog { constructor(app2) { super(); this.app = app2; - this.element = $el("dialog.comfy-group-manage", { + this.element = $el("dialog.seap-group-manage", { parent: document.body }); } @@ -691,11 +691,11 @@ class ManageGroupDialog extends ComfyDialog { (a, b) => a.localeCompare(b) ); this.innerNodesList = $el( - "ul.comfy-group-manage-list-items" + "ul.seap-group-manage-list-items" ); - this.widgetsPage = $el("section.comfy-group-manage-node-page"); - this.inputsPage = $el("section.comfy-group-manage-node-page"); - this.outputsPage = $el("section.comfy-group-manage-node-page"); + this.widgetsPage = $el("section.seap-group-manage-node-page"); + this.inputsPage = $el("section.seap-group-manage-node-page"); + this.outputsPage = $el("section.seap-group-manage-node-page"); const pages = $el("div", [ this.widgetsPage, this.inputsPage, @@ -717,7 +717,7 @@ class ManageGroupDialog extends ComfyDialog { }; return p; }, {}); - const outer = $el("div.comfy-group-manage-outer", [ + const outer = $el("div.seap-group-manage-outer", [ $el("header", [ $el("h2", "Group Nodes"), $el( @@ -737,8 +737,8 @@ class ManageGroupDialog extends ComfyDialog { ) ]), $el("main", [ - $el("section.comfy-group-manage-list", this.innerNodesList), - $el("section.comfy-group-manage-node", [ + $el("section.seap-group-manage-list", this.innerNodesList), + $el("section.seap-group-manage-node", [ $el( "header", Object.values(this.tabs).map((t) => t.tab) @@ -748,7 +748,7 @@ class ManageGroupDialog extends ComfyDialog { ]), $el("footer", [ $el( - "button.comfy-btn", + "button.seap-btn", { onclick: /* @__PURE__ */ __name((e) => { const node = app.graph.nodes.find( @@ -774,7 +774,7 @@ class ManageGroupDialog extends ComfyDialog { "Delete Group Node" ), $el( - "button.comfy-btn", + "button.seap-btn", { onclick: /* @__PURE__ */ __name(async () => { let nodesByType; @@ -840,7 +840,7 @@ class ManageGroupDialog extends ComfyDialog { "Save" ), $el( - "button.comfy-btn", + "button.seap-btn", { onclick: /* @__PURE__ */ __name(() => this.element.close(), "onclick") }, "Close" ) @@ -2321,7 +2321,7 @@ app.registerExtension({ return; } if (event.key === "Escape") { - const modals = document.querySelectorAll(".comfy-modal"); + const modals = document.querySelectorAll(".seap-modal"); const modal = Array.from(modals).find( (modal2) => window.getComputedStyle(modal2).getPropertyValue("display") !== "none" ); @@ -2484,8 +2484,8 @@ class MaskEditorDialog extends ComfyDialog { is_layout_created = false; constructor() { super(); - this.element = $el("div.comfy-modal", { parent: document.body }, [ - $el("div.comfy-modal-content", [...this.createButtons()]) + this.element = $el("div.seap-modal", { parent: document.body }, [ + $el("div.seap-modal-content", [...this.createButtons()]) ]); } createButtons() { @@ -2517,7 +2517,7 @@ class MaskEditorDialog extends ComfyDialog { divElement.style.fontFamily = "sans-serif"; divElement.style.marginRight = "4px"; divElement.style.color = "var(--input-text)"; - divElement.style.backgroundColor = "var(--comfy-input-bg)"; + divElement.style.backgroundColor = "var(--seap-input-bg)"; divElement.style.borderRadius = "8px"; divElement.style.borderColor = "var(--border-color)"; divElement.style.borderStyle = "solid"; @@ -2547,7 +2547,7 @@ class MaskEditorDialog extends ComfyDialog { divElement.style.fontFamily = "sans-serif"; divElement.style.marginRight = "4px"; divElement.style.color = "var(--input-text)"; - divElement.style.backgroundColor = "var(--comfy-input-bg)"; + divElement.style.backgroundColor = "var(--seap-input-bg)"; divElement.style.borderRadius = "8px"; divElement.style.borderColor = "var(--border-color)"; divElement.style.borderStyle = "solid"; @@ -2578,7 +2578,7 @@ class MaskEditorDialog extends ComfyDialog { divElement.style.fontFamily = "sans-serif"; divElement.style.marginRight = "4px"; divElement.style.color = "var(--input-text)"; - divElement.style.backgroundColor = "var(--comfy-input-bg)"; + divElement.style.backgroundColor = "var(--seap-input-bg)"; divElement.style.borderRadius = "8px"; divElement.style.borderColor = "var(--border-color)"; divElement.style.borderStyle = "solid"; @@ -3299,7 +3299,7 @@ app.registerExtension({ } }); const id = "Comfy.NodeTemplates"; -const file = "comfy.templates.json"; +const file = "seap.templates.json"; class ManageTemplates extends ComfyDialog { static { __name(this, "ManageTemplates"); @@ -3314,7 +3314,7 @@ class ManageTemplates extends ComfyDialog { this.load().then((v) => { this.templates = v; }); - this.element.classList.add("comfy-manage-templates"); + this.element.classList.add("seap-manage-templates"); this.draggedEl = null; this.saveVisualCue = null; this.emptyImg = new Image(); @@ -3454,7 +3454,7 @@ class ManageTemplates extends ComfyDialog { gridTemplateColumns: "1fr auto", border: "1px dashed transparent", gap: "5px", - backgroundColor: "var(--comfy-menu-bg)" + backgroundColor: "var(--seap-menu-bg)" }, ondragstart: /* @__PURE__ */ __name((e) => { this.draggedEl = e.currentTarget; @@ -3528,14 +3528,14 @@ class ManageTemplates extends ComfyDialog { el.style.transitionDuration = "0s"; this.saveVisualCue = setTimeout(function() { el.style.transitionDuration = ".7s"; - el.style.backgroundColor = "var(--comfy-input-bg)"; + el.style.backgroundColor = "var(--seap-input-bg)"; }, 15); }, "onchange"), onkeypress: /* @__PURE__ */ __name((e) => { var el = e.target; clearTimeout(this.saveVisualCue); el.style.transitionDuration = "0s"; - el.style.backgroundColor = "var(--comfy-input-bg)"; + el.style.backgroundColor = "var(--seap-input-bg)"; }, "onkeypress"), $: /* @__PURE__ */ __name((el) => nameInput = el, "$") }) @@ -4457,7 +4457,7 @@ app.registerExtension({ AUDIO_UI(node, inputName) { const audio = document.createElement("audio"); audio.controls = true; - audio.classList.add("comfy-audio"); + audio.classList.add("seap-audio"); audio.setAttribute("name", "media"); const audioUIWidget = node.addDOMWidget( inputName, diff --git a/web/assets/index-DGAbdBYF.js b/web/assets/index-DGAbdBYF.js index 8219afa50..69fdbb552 100644 --- a/web/assets/index-DGAbdBYF.js +++ b/web/assets/index-DGAbdBYF.js @@ -19450,7 +19450,7 @@ var NodeSourceType = /* @__PURE__ */ ((NodeSourceType2) => { })(NodeSourceType || {}); const UNKNOWN_NODE_SOURCE = { type: "unknown", - className: "comfy-unknown", + className: "seap-unknown", displayText: "Unknown", badgeText: "?" }; @@ -19462,10 +19462,10 @@ const getNodeSource = /* @__PURE__ */ __name((python_module) => { return UNKNOWN_NODE_SOURCE; } const modules = python_module.split("."); - if (["nodes", "comfy_extras"].includes(modules[0])) { + if (["nodes", "seap_extras"].includes(modules[0])) { return { type: "core", - className: "comfy-core", + className: "seap-core", displayText: "Comfy Core", badgeText: "🦊" }; @@ -19473,7 +19473,7 @@ const getNodeSource = /* @__PURE__ */ __name((python_module) => { const displayName = shortenNodeName(modules[1]); return { type: "custom_nodes", - className: "comfy-custom-nodes", + className: "seap-custom-nodes", displayText: displayName, badgeText: displayName }; @@ -23059,8 +23059,8 @@ let ComfyDialog$1 = class ComfyDialog2 extends EventTarget { constructor(type = "div", buttons = null) { super(); this.#buttons = buttons; - this.element = $el(type + ".comfy-modal", { parent: document.body }, [ - $el("div.comfy-modal-content", [ + this.element = $el(type + ".seap-modal", { parent: document.body }, [ + $el("div.seap-modal-content", [ $el("p", { $: /* @__PURE__ */ __name((p2) => this.textElement = p2, "$") }), ...this.createButtons() ]) @@ -23098,14 +23098,14 @@ function toggleSwitch(name, items2, e) { let elements; function updateSelected(index2) { if (selectedIndex != null) { - elements[selectedIndex].classList.remove("comfy-toggle-selected"); + elements[selectedIndex].classList.remove("seap-toggle-selected"); } onChange10?.({ item: items2[index2], prev: selectedIndex == null ? void 0 : items2[selectedIndex] }); selectedIndex = index2; - elements[selectedIndex].classList.add("comfy-toggle-selected"); + elements[selectedIndex].classList.add("seap-toggle-selected"); } __name(updateSelected, "updateSelected"); elements = items2.map((item, i2) => { @@ -23132,7 +23132,7 @@ function toggleSwitch(name, items2, e) { } return toggle; }); - const container = $el("div.comfy-toggle-switch", elements); + const container = $el("div.seap-toggle-switch", elements); if (selectedIndex == null) { elements[0].children[0].checked = true; updateSelected(0); @@ -23570,7 +23570,7 @@ const CORE_SETTINGS = [ type: "boolean", defaultValue: false, onChange: /* @__PURE__ */ __name((value3) => { - const element = document.getElementById("comfy-dev-save-api-button"); + const element = document.getElementById("seap-dev-save-api-button"); if (element) { element.style.display = value3 ? "flex" : "none"; } @@ -23707,15 +23707,15 @@ class ComfySettingsDialog extends ComfyDialog$1 { this.element = $el( "dialog", { - id: "comfy-settings-dialog", + id: "seap-settings-dialog", parent: document.body }, [ - $el("table.comfy-modal-content.comfy-table", [ + $el("table.seap-modal-content.seap-table", [ $el( "caption", { textContent: `Settings (v${frontendVersion})` }, - $el("button.comfy-btn", { + $el("button.seap-btn", { type: "button", textContent: "×", onclick: /* @__PURE__ */ __name(() => { @@ -23883,7 +23883,7 @@ class ComfySettingsDialog extends ComfyDialog$1 { const labelCell = $el("td", [ $el("label", { for: htmlID, - classList: [tooltip !== "" ? "comfy-tooltip-indicator" : ""], + classList: [tooltip !== "" ? "seap-tooltip-indicator" : ""], textContent: name }) ]); @@ -30926,7 +30926,7 @@ function render$Q(_ctx, _cache, $props, $setup, $data, $options) { __name(render$Q, "render$Q"); script$R.render = render$Q; const _withScopeId$9 = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-0a88b934"), n = n(), popScopeId(), n), "_withScopeId$9"); -const _hoisted_1$Z = { class: "comfy-missing-nodes" }; +const _hoisted_1$Z = { class: "seap-missing-nodes" }; const _hoisted_2$N = /* @__PURE__ */ _withScopeId$9(() => /* @__PURE__ */ createBaseVNode("h4", { class: "warning-title" }, "Warning: Missing Node Types", -1)); const _hoisted_3$h = /* @__PURE__ */ _withScopeId$9(() => /* @__PURE__ */ createBaseVNode("p", { class: "warning-description" }, " When loading the graph, the following node types were not found: ", -1)); const _hoisted_4$b = { class: "missing-node-item" }; @@ -32820,7 +32820,7 @@ function render$K(_ctx, _cache, $props, $setup, $data, $options) { __name(render$K, "render$K"); script$L.render = render$K; const _withScopeId$8 = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-d0515260"), n = n(), popScopeId(), n), "_withScopeId$8"); -const _hoisted_1$T = { class: "comfy-missing-models" }; +const _hoisted_1$T = { class: "seap-missing-models" }; const _hoisted_2$H = /* @__PURE__ */ _withScopeId$8(() => /* @__PURE__ */ createBaseVNode("h4", { class: "warning-title" }, "Warning: Missing Models", -1)); const _hoisted_3$f = /* @__PURE__ */ _withScopeId$8(() => /* @__PURE__ */ createBaseVNode("p", { class: "warning-description" }, " When loading the graph, the following models were not found: ", -1)); const _hoisted_4$9 = { class: "warning-options" }; @@ -82950,7 +82950,7 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({ } }); const _withScopeId$1 = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-25398546"), n = n(), popScopeId(), n), "_withScopeId$1"); -const _hoisted_1$6 = { class: "comfy-error-report" }; +const _hoisted_1$6 = { class: "seap-error-report" }; const _hoisted_2$1 = { class: "wrapper-pre" }; const _hoisted_3$1 = { class: "action-container" }; const repoOwner = "comfyanonymous"; @@ -83763,7 +83763,7 @@ function dragElement(dragEl, settings) { function elementDrag(e) { e = e || window.event; e.preventDefault(); - dragEl.classList.add("comfy-menu-manual-pos"); + dragEl.classList.add("seap-menu-manual-pos"); posDiffX = e.clientX - posStartX; posDiffY = e.clientY - posStartY; posStartX = e.clientX; @@ -83803,7 +83803,7 @@ class ComfyList { this.#text = text2; this.#type = type || text2.toLowerCase(); this.#reverse = reverse || false; - this.element = $el("div.comfy-list"); + this.element = $el("div.seap-list"); this.element.style.display = "none"; } get visible() { @@ -83816,7 +83816,7 @@ class ComfyList { $el("h4", { textContent: section }), - $el("div.comfy-list-items", [ + $el("div.seap-list-items", [ ...(this.#reverse ? items2[section].reverse() : items2[section]).map( (item) => { const removeAction = "remove" in item ? item.remove : { @@ -83853,7 +83853,7 @@ class ComfyList { ) ]) ]), - $el("div.comfy-list-actions", [ + $el("div.seap-list-actions", [ $el("button", { textContent: "Clear " + this.#text, onclick: /* @__PURE__ */ __name(async () => { @@ -83924,7 +83924,7 @@ class ComfyUI { } setup(containerElement) { const fileInput2 = $el("input", { - id: "comfy-file-input", + id: "seap-file-input", type: "file", accept: ".json,image/png,.latent,.safetensors,image/webp,audio/flac", style: { display: "none" }, @@ -83965,7 +83965,7 @@ class ComfyUI { } }); this.menuHamburger = $el( - "div.comfy-menu-hamburger", + "div.seap-menu-hamburger", { parent: containerElement, onclick: /* @__PURE__ */ __name(() => { @@ -83975,9 +83975,9 @@ class ComfyUI { }, [$el("div"), $el("div"), $el("div")] ); - this.menuContainer = $el("div.comfy-menu", { parent: containerElement }, [ + this.menuContainer = $el("div.seap-menu", { parent: containerElement }, [ $el( - "div.drag-handle.comfy-menu-header", + "div.drag-handle.seap-menu-header", { style: { overflow: "hidden", @@ -83988,13 +83988,13 @@ class ComfyUI { }, [ $el("span.drag-handle"), - $el("span.comfy-menu-queue-size", { $: /* @__PURE__ */ __name((q) => this.queueSize = q, "$") }), - $el("div.comfy-menu-actions", [ - $el("button.comfy-settings-btn", { + $el("span.seap-menu-queue-size", { $: /* @__PURE__ */ __name((q) => this.queueSize = q, "$") }), + $el("div.seap-menu-actions", [ + $el("button.seap-settings-btn", { textContent: "⚙️", onclick: showSettingsDialog }), - $el("button.comfy-close-menu-btn", { + $el("button.seap-close-menu-btn", { textContent: "×", onclick: /* @__PURE__ */ __name(() => { this.menuContainer.style.display = "none"; @@ -84004,7 +84004,7 @@ class ComfyUI { ]) ] ), - $el("button.comfy-queue-btn", { + $el("button.seap-queue-btn", { id: "queue-button", textContent: "Queue Prompt", onclick: /* @__PURE__ */ __name(() => app$1.queuePrompt(0, this.batchCount), "onclick") @@ -84078,7 +84078,7 @@ class ComfyUI { ]) ] ), - $el("div.comfy-menu-btns", [ + $el("div.seap-menu-btns", [ $el("button", { id: "queue-front-button", textContent: "Queue Front", @@ -84086,7 +84086,7 @@ class ComfyUI { }), $el("button", { $: /* @__PURE__ */ __name((b) => this.queue.button = b, "$"), - id: "comfy-view-queue-button", + id: "seap-view-queue-button", textContent: "View Queue", onclick: /* @__PURE__ */ __name(() => { this.history.hide(); @@ -84095,7 +84095,7 @@ class ComfyUI { }), $el("button", { $: /* @__PURE__ */ __name((b) => this.history.button = b, "$"), - id: "comfy-view-history-button", + id: "seap-view-history-button", textContent: "View History", onclick: /* @__PURE__ */ __name(() => { this.queue.hide(); @@ -84106,14 +84106,14 @@ class ComfyUI { this.queue.element, this.history.element, $el("button", { - id: "comfy-save-button", + id: "seap-save-button", textContent: "Save", onclick: /* @__PURE__ */ __name(() => { useCommandStore().execute("Comfy.ExportWorkflow"); }, "onclick") }), $el("button", { - id: "comfy-dev-save-api-button", + id: "seap-dev-save-api-button", textContent: "Save (API Format)", style: { width: "100%", display: "none" }, onclick: /* @__PURE__ */ __name(() => { @@ -84121,23 +84121,23 @@ class ComfyUI { }, "onclick") }), $el("button", { - id: "comfy-load-button", + id: "seap-load-button", textContent: "Load", onclick: /* @__PURE__ */ __name(() => fileInput2.click(), "onclick") }), $el("button", { - id: "comfy-refresh-button", + id: "seap-refresh-button", textContent: "Refresh", onclick: /* @__PURE__ */ __name(() => app$1.refreshComboInNodes(), "onclick") }), $el("button", { - id: "comfy-clipspace-button", + id: "seap-clipspace-button", textContent: "Clipspace", // @ts-expect-error Move to ComfyApp onclick: /* @__PURE__ */ __name(() => app$1.openClipspace(), "onclick") }), $el("button", { - id: "comfy-clear-button", + id: "seap-clear-button", textContent: "Clear", onclick: /* @__PURE__ */ __name(() => { if (!useSettingStore().get("Comfy.ConfirmClear") || confirm("Clear workflow?")) { @@ -84149,7 +84149,7 @@ class ComfyUI { }, "onclick") }), $el("button", { - id: "comfy-load-default-button", + id: "seap-load-default-button", textContent: "Load Default", onclick: /* @__PURE__ */ __name(async () => { if (!useSettingStore().get("Comfy.ConfirmClear") || confirm("Load default workflow?")) { @@ -84159,7 +84159,7 @@ class ComfyUI { }, "onclick") }), $el("button", { - id: "comfy-reset-view-button", + id: "seap-reset-view-button", textContent: "Reset View", onclick: /* @__PURE__ */ __name(async () => { app$1.resetView(); @@ -84348,13 +84348,13 @@ class ComfyLoggingDialog extends ComfyDialog { }; const keys2 = Object.keys(cols); const headers = Object.values(cols).map( - (title) => $el("div.comfy-logging-title", { + (title) => $el("div.seap-logging-title", { textContent: title }) ); const rows3 = entries.map((entry, i2) => { return $el( - "div.comfy-logging-log", + "div.seap-logging-log", { $: /* @__PURE__ */ __name((el) => el.style.setProperty( "--row-bg", @@ -84382,7 +84382,7 @@ class ComfyLoggingDialog extends ComfyDialog { ); }); const grid = $el( - "div.comfy-logging-logs", + "div.seap-logging-logs", { style: { gridTemplateColumns: `repeat(${headers.length}, 1fr)` @@ -84588,9 +84588,9 @@ function computeSize(size2) { widgetHeight += w2.computeSize()[1] + 4; } else if (w2.element) { const styles = getComputedStyle(w2.element); - let minHeight = w2.options.getMinHeight?.() ?? parseInt(styles.getPropertyValue("--comfy-widget-min-height")); - let maxHeight = w2.options.getMaxHeight?.() ?? parseInt(styles.getPropertyValue("--comfy-widget-max-height")); - let prefHeight = w2.options.getHeight?.() ?? styles.getPropertyValue("--comfy-widget-height"); + let minHeight = w2.options.getMinHeight?.() ?? parseInt(styles.getPropertyValue("--seap-widget-min-height")); + let maxHeight = w2.options.getMaxHeight?.() ?? parseInt(styles.getPropertyValue("--seap-widget-max-height")); + let prefHeight = w2.options.getHeight?.() ?? styles.getPropertyValue("--seap-widget-height"); if (prefHeight.endsWith?.("%")) { prefHeight = size2[1] * (parseFloat(prefHeight.substring(0, prefHeight.length - 1)) / 100); } else { @@ -85088,7 +85088,7 @@ function createIntWidget(node2, inputName, inputData, app2, isSeedInput = false) __name(createIntWidget, "createIntWidget"); function addMultilineWidget(node2, name, opts, app2) { const inputEl = document.createElement("textarea"); - inputEl.className = "comfy-multiline-input"; + inputEl.className = "seap-multiline-input"; inputEl.value = opts.defaultVal; inputEl.placeholder = opts.placeholder || name; if (app2.vueAppReady) { @@ -86066,7 +86066,7 @@ function calculateImageGrid(imgs, dw, dh) { } __name(calculateImageGrid, "calculateImageGrid"); function createImageHost(node2) { - const el = $el("div.comfy-img-preview"); + const el = $el("div.seap-img-preview"); let currentImgs; let first4 = true; function updateSize() { @@ -86079,9 +86079,9 @@ function createImageHost(node2) { if (elH < 190) { elH = 190; } - el.style.setProperty("--comfy-widget-min-height", elH.toString()); + el.style.setProperty("--seap-widget-min-height", elH.toString()); } else { - el.style.setProperty("--comfy-widget-min-height", null); + el.style.setProperty("--seap-widget-min-height", null); } const nw = node2.size[0]; ({ cellWidth: w2, cellHeight: h2 } = calculateImageGrid( @@ -86091,8 +86091,8 @@ function createImageHost(node2) { )); w2 += "px"; h2 += "px"; - el.style.setProperty("--comfy-img-preview-width", w2); - el.style.setProperty("--comfy-img-preview-height", h2); + el.style.setProperty("--seap-img-preview-width", w2); + el.style.setProperty("--seap-img-preview-height", h2); } } __name(updateSize, "updateSize"); @@ -86948,7 +86948,7 @@ class ComfyAsyncDialog extends ComfyDialog$1 { #resolve; constructor(actions) { super( - "dialog.comfy-dialog.comfyui-dialog", + "dialog.seap-dialog.comfyui-dialog", actions?.map((opt) => { if (typeof opt === "string") { opt = { text: opt }; diff --git a/web/assets/userSelection-Duxc-t_S.js b/web/assets/userSelection-Duxc-t_S.js index 9a8ee98a9..183663370 100644 --- a/web/assets/userSelection-Duxc-t_S.js +++ b/web/assets/userSelection-Duxc-t_S.js @@ -15,7 +15,7 @@ class UserSelectionScreen { __name(this, "UserSelectionScreen"); } async show(users, user) { - const userSelection = document.getElementById("comfy-user-selection"); + const userSelection = document.getElementById("seap-user-selection"); userSelection.style.display = ""; return new Promise((resolve) => { const input = userSelection.getElementsByTagName("input")[0];