comfy-webui-core 0.1.0__py3-none-any.whl

comfy_webui_core/__init__.py

@@ -0,0 +1,73 @@
+"""
+Comfy Web UI Core Framework.
+
+Provides dynamic ComfyUI workflow engine, Gradio WebUI dynamic assembly,
+MCP server endpoints, multi-backend routing, and chain injector topology.
+"""
+
+from .context import set_app_root, get_app_root
+from .workflow_assembler import WorkflowAssembler
+from .ui_builder import build_gradio_ui
+from .ui_loader import discover_ui_modules, load_ui_layout
+from .backend_manager import backend_manager
+from .node_info_manager import (
+    fetch_and_cache_object_info,
+    get_node_info,
+    get_all_node_info,
+)
+from .job_manager import (
+    create_job,
+    get_job,
+    update_job,
+    get_latest_running_job_for_module,
+)
+from .yaml_loader import load_and_merge_yaml, load_and_merge_yaml_from_module
+
+from . import config
+from . import workflow_assembler
+from . import ui_builder
+from . import ui_loader
+from . import backend_manager as backend_manager_mod
+from . import node_info_manager as node_info_manager_mod
+from . import job_manager as job_manager_mod
+from . import comfy_api
+from . import shared_ui
+from . import utils
+from . import input_processors
+from . import yaml_loader
+from . import download_utils
+from . import model_downloader
+from . import chain_injectors
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "set_app_root",
+    "get_app_root",
+    "WorkflowAssembler",
+    "build_gradio_ui",
+    "discover_ui_modules",
+    "load_ui_layout",
+    "backend_manager",
+    "fetch_and_cache_object_info",
+    "get_node_info",
+    "get_all_node_info",
+    "create_job",
+    "get_job",
+    "update_job",
+    "get_latest_running_job_for_module",
+    "load_and_merge_yaml",
+    "load_and_merge_yaml_from_module",
+    "config",
+    "workflow_assembler",
+    "ui_builder",
+    "ui_loader",
+    "comfy_api",
+    "shared_ui",
+    "utils",
+    "input_processors",
+    "yaml_loader",
+    "download_utils",
+    "model_downloader",
+    "chain_injectors",
+]

comfy_webui_core/backend_manager.py

@@ -0,0 +1,70 @@
+import requests
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from .config import COMFYUI_BACKENDS
+
+class BackendManager:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(BackendManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+            
+        self.backends = COMFYUI_BACKENDS
+        self.active_backend_name = "default"
+        self._initialized = True
+        print(f"[BackendManager] Initialized with default backend '{self.active_backend_name}'.")
+
+    def get_active_backend_url(self):
+        return self.backends.get(self.active_backend_name)
+
+    def get_all_backend_urls(self):
+        return list(self.backends.values())
+
+    def _free_backend_memory(self, backend_name, backend_url):
+        try:
+            print(f"[BackendManager] Sending /free request to {backend_name} ({backend_url})...")
+            response = requests.post(
+                f"{backend_url}/free",
+                json={"unload_models": True, "free_memory": True},
+                timeout=20
+            )
+            response.raise_for_status()
+            print(f"[BackendManager] Successfully freed memory for {backend_name}.")
+        except requests.exceptions.RequestException as e:
+            print(f"[BackendManager] Warning: Could not free memory for backend '{backend_name}'. "
+                  f"Is the backend running and does it support the /free endpoint? Error: {e}")
+
+    def switch_backend(self, target_backend_name: str):
+        if target_backend_name not in self.backends:
+            print(f"[BackendManager] Error: Attempted to switch to an unknown backend '{target_backend_name}'. "
+                  f"Falling back to 'default'.")
+            target_backend_name = "default"
+        
+        if self.active_backend_name == target_backend_name:
+            print(f"[BackendManager] Backend '{target_backend_name}' is already active. No switch needed.")
+            return
+
+        print(f"[BackendManager] Switching backend from '{self.active_backend_name}' to '{target_backend_name}'...")
+        
+        inactive_backends = {name: url for name, url in self.backends.items() if name != target_backend_name}
+        
+        if inactive_backends:
+            print(f"[BackendManager] Freeing up resources on {len(inactive_backends)} inactive backend(s)...")
+            with ThreadPoolExecutor(max_workers=len(inactive_backends)) as executor:
+                futures = [executor.submit(self._free_backend_memory, name, url) for name, url in inactive_backends.items()]
+                for future in futures:
+                    future.result()
+
+        self.active_backend_name = target_backend_name
+        print(f"[BackendManager] Switch complete. Active backend is now '{self.active_backend_name}'.")
+
+backend_manager = BackendManager()

comfy_webui_core/chain_injectors/easycache_injector.py

@@ -0,0 +1,40 @@
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    ksampler_names = chain_definition.get('ksampler_node', 'ksampler')
+    if not isinstance(ksampler_names, list):
+        ksampler_names = [ksampler_names]
+
+    nodes_injected = 0
+    for ksampler_name in ksampler_names:
+        if ksampler_name not in assembler.node_map:
+            print(f"Warning: [EasyCache Injector] KSampler node '{ksampler_name}' not found. Skipping.")
+            continue
+        
+        ksampler_id = assembler.node_map[ksampler_name]
+
+        if 'model' not in assembler.workflow[ksampler_id]['inputs']:
+            print(f"Warning: [EasyCache Injector] KSampler node '{ksampler_name}' is missing 'model' input. Skipping.")
+            continue
+            
+        current_model_connection = assembler.workflow[ksampler_id]['inputs']['model']
+        
+        easycache_id = assembler._get_unique_id()
+        easycache_node = assembler._get_node_template_from_api("EasyCache")
+        
+        easycache_node['inputs']['reuse_threshold'] = chain_definition.get('reuse_threshold', 0.2)
+        easycache_node['inputs']['start_percent'] = chain_definition.get('start_percent', 0.15)
+        easycache_node['inputs']['end_percent'] = chain_definition.get('end_percent', 0.95)
+        easycache_node['inputs']['verbose'] = chain_definition.get('verbose', False)
+        
+        easycache_node['inputs']['model'] = current_model_connection
+        assembler.workflow[easycache_id] = easycache_node
+        
+        assembler.workflow[ksampler_id]['inputs']['model'] = [easycache_id, 0]
+        
+        print(f"EasyCache injector applied. KSampler '{ksampler_name}' model input re-routed through EasyCache node.")
+        nodes_injected += 1
+
+    if nodes_injected > 0:
+        print(f"EasyCache injector finished. Applied to {nodes_injected} KSampler node(s).")

comfy_webui_core/chain_injectors/lora_injector.py

@@ -0,0 +1,67 @@
+from copy import deepcopy
+
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    start_node_name = chain_definition.get('start')
+    start_node_id = None
+    if start_node_name:
+        if start_node_name not in assembler.node_map:
+            print(f"Warning: Start node '{start_node_name}' for dynamic LoRA chain not found. Skipping chain.")
+            return
+        start_node_id = assembler.node_map[start_node_name]
+    
+    output_map = chain_definition.get('output_map', {})
+    current_connections = {}
+    for key, type_name in output_map.items():
+        if ':' in str(key):
+            node_name, idx_str = key.split(':')
+            if node_name not in assembler.node_map:
+                print(f"Warning: Node '{node_name}' in chain's output_map not found. Skipping.")
+                continue
+            node_id = assembler.node_map[node_name]
+            start_output_idx = int(idx_str)
+            current_connections[type_name] = [node_id, start_output_idx]
+        elif start_node_id:
+            start_output_idx = int(key)
+            current_connections[type_name] = [start_node_id, start_output_idx]
+        else:
+            print(f"Warning: LoRA chain has no 'start' node defined, and an output_map key '{key}' is not in 'node:index' format. Skipping this connection.")
+
+
+    input_map = chain_definition.get('input_map', {})
+    chain_output_map = chain_definition.get('template_output_map', { "0": "model", "1": "clip" })
+
+    for item_data in chain_items:
+        template_name = chain_definition['template']
+        template = assembler._get_node_template_from_api(template_name)
+        node_data = deepcopy(template)
+        
+        for param_name, value in item_data.items():
+            if param_name in node_data['inputs']:
+                node_data['inputs'][param_name] = value
+        
+        for type_name, input_name in input_map.items():
+            if type_name in current_connections:
+                node_data['inputs'][input_name] = current_connections[type_name]
+
+        new_node_id = assembler._get_unique_id()
+        assembler.workflow[new_node_id] = node_data
+        
+        for idx_str, type_name in chain_output_map.items():
+            current_connections[type_name] = [new_node_id, int(idx_str)]
+
+    end_input_map = chain_definition.get('end_input_map', {})
+    for type_name, targets in end_input_map.items():
+        if type_name in current_connections:
+            if not isinstance(targets, list):
+                targets = [targets]
+            
+            for target_str in targets:
+                end_node_name, end_input_name = target_str.split(':')
+                if end_node_name in assembler.node_map:
+                    end_node_id = assembler.node_map[end_node_name]
+                    assembler.workflow[end_node_id]['inputs'][end_input_name] = current_connections[type_name]
+                else:
+                    print(f"Warning: End node '{end_node_name}' for dynamic chain not found. Skipping connection.")

comfy_webui_core/chain_injectors/lora_model_only_injector.py

@@ -0,0 +1,59 @@
+from copy import deepcopy
+
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    output_map = chain_definition.get('output_map', {})
+    
+    current_model_connection = None
+    for key, type_name in output_map.items():
+        if type_name == "model":
+            node_name, idx_str = key.split(':')
+            if node_name in assembler.node_map:
+                node_id = assembler.node_map[node_name]
+                current_model_connection = [node_id, int(idx_str)]
+                break
+    
+    if not current_model_connection:
+        print(f"Warning: 'output_map' for LoRA (Model Only) chain must define a 'model' type from a valid node. Skipping.")
+        return
+
+    template_name = chain_definition.get('template')
+    if not template_name:
+        print(f"Warning: No 'template' defined for LoRA (Model Only) chain. Skipping.")
+        return
+
+    for item_data in chain_items:
+        template = assembler._get_node_template_from_api(template_name)
+        node_data = deepcopy(template)
+        
+        for param_name, value in item_data.items():
+            if param_name in node_data['inputs']:
+                node_data['inputs'][param_name] = value
+        
+        node_data['inputs']['model'] = current_model_connection
+
+        new_node_id = assembler._get_unique_id()
+        assembler.workflow[new_node_id] = node_data
+        
+        current_model_connection = [new_node_id, 0]
+
+    end_input_map = chain_definition.get('end_input_map', {})
+    model_targets = end_input_map.get('model', [])
+    if not isinstance(model_targets, list):
+        model_targets = [model_targets]
+
+    for target_str in model_targets:
+        try:
+            end_node_name, end_input_name = target_str.split(':')
+            if end_node_name in assembler.node_map:
+                end_node_id = assembler.node_map[end_node_name]
+                assembler.workflow[end_node_id]['inputs'][end_input_name] = current_model_connection
+            else:
+                print(f"Warning: End node '{end_node_name}' for dynamic LoRA (Model Only) chain not found. Skipping connection.")
+        except ValueError:
+            print(f"Warning: Invalid target format '{target_str}' in end_input_map. Skipping.")
+            
+    if model_targets:
+        print(f"LoRA (Model Only) injector applied. Re-routed model through {len(chain_items)} LoRA(s).")

comfy_webui_core/chain_injectors/reference_latent_injector.py

@@ -0,0 +1,157 @@
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    guider_node_name = chain_definition.get('guider_node')
+    guider_target_inputs = chain_definition.get('guider_target_inputs', [])
+    start_connections_map = chain_definition.get('start_connections', {})
+    vae_node_name = chain_definition.get('vae_node', 'vae_loader')
+
+    if guider_node_name and guider_node_name in assembler.node_map and guider_target_inputs:
+        guider_id = assembler.node_map[guider_node_name]
+        if vae_node_name not in assembler.node_map:
+            print(f"Warning: VAE node '{vae_node_name}' not found for Guider chain. Skipping.")
+            return
+        vae_node_id = assembler.node_map[vae_node_name]
+        
+        print(f"ReferenceLatent injector targeting DualCFGGuider node '{guider_node_name}'.")
+
+        current_connections = {}
+        for target_input in guider_target_inputs:
+            conn_str = start_connections_map.get(target_input)
+            if not conn_str:
+                print(f"Warning: No start connection defined for '{target_input}' in Guider chain. Skipping this input.")
+                continue
+            try:
+                node_name, idx_str = conn_str.split(':')
+                node_id = assembler.node_map[node_name]
+                current_connections[target_input] = [node_id, int(idx_str)]
+            except (ValueError, KeyError):
+                print(f"Warning: Invalid start connection '{conn_str}' for '{target_input}'. Skipping.")
+
+        encoded_latents = []
+        for i, img_filename in enumerate(chain_items):
+            load_id = assembler._get_unique_id()
+            load_node = assembler._get_node_template_from_api("LoadImage")
+            load_node['inputs']['image'] = img_filename
+            assembler.workflow[load_id] = load_node
+            
+            scale_id = assembler._get_unique_id()
+            scale_node = assembler._get_node_template_from_api("ImageScaleToTotalPixels")
+            scale_node['inputs']['megapixels'] = 1.0
+            scale_node['inputs']['upscale_method'] = "lanczos"
+            scale_node['inputs']['image'] = [load_id, 0]
+            assembler.workflow[scale_id] = scale_node
+            
+            vae_encode_id = assembler._get_unique_id()
+            vae_encode_node = assembler._get_node_template_from_api("VAEEncode")
+            vae_encode_node['inputs']['pixels'] = [scale_id, 0]
+            vae_encode_node['inputs']['vae'] = [vae_node_id, 0]
+            assembler.workflow[vae_encode_id] = vae_encode_node
+            encoded_latents.append([vae_encode_id, 0])
+        
+        for target_input_name, start_connection in current_connections.items():
+            current_chain_head = start_connection
+            for i, latent_conn in enumerate(encoded_latents):
+                ref_latent_id = assembler._get_unique_id()
+                ref_latent_node = assembler._get_node_template_from_api("ReferenceLatent")
+                ref_latent_node['inputs']['conditioning'] = current_chain_head
+                ref_latent_node['inputs']['latent'] = latent_conn
+                ref_latent_node['_meta']['title'] = f"{target_input_name} RefLatent {i+1}"
+                assembler.workflow[ref_latent_id] = ref_latent_node
+                current_chain_head = [ref_latent_id, 0]
+            
+            assembler.workflow[guider_id]['inputs'][target_input_name] = current_chain_head
+            print(f"  - Input '{target_input_name}' of node '{guider_node_name}' re-routed through {len(chain_items)} reference images.")
+
+        return
+
+    flux_guidance_name = chain_definition.get('flux_guidance_node')
+    ksampler_name = chain_definition.get('ksampler_node', 'ksampler')
+
+    if ksampler_name not in assembler.node_map:
+        print(f"Warning: KSampler node '{ksampler_name}' not found for ReferenceLatent chain. Skipping.")
+        return
+    if vae_node_name not in assembler.node_map:
+        print(f"Warning: VAE loader node '{vae_node_name}' not found for ReferenceLatent chain. Skipping.")
+        return
+
+    ksampler_id = assembler.node_map[ksampler_name]
+    vae_node_id = assembler.node_map[vae_node_name]
+
+    pos_target_node_id = None
+    pos_target_input_name = None
+    if flux_guidance_name and flux_guidance_name in assembler.node_map:
+        flux_guidance_id = assembler.node_map[flux_guidance_name]
+        if 'conditioning' in assembler.workflow[flux_guidance_id]['inputs']:
+            pos_target_node_id = flux_guidance_id
+            pos_target_input_name = 'conditioning'
+            print(f"ReferenceLatent injector targeting FluxGuidance node '{flux_guidance_name}' for positive chain.")
+    
+    if not pos_target_node_id:
+        if 'positive' in assembler.workflow[ksampler_id]['inputs']:
+            pos_target_node_id = ksampler_id
+            pos_target_input_name = 'positive'
+            print(f"ReferenceLatent injector targeting KSampler node '{ksampler_name}' for positive chain.")
+        else:
+            print(f"Warning: Could not find a valid positive injection point for ReferenceLatent chain. Skipping.")
+            return
+
+    current_pos_conditioning = assembler.workflow[pos_target_node_id]['inputs'][pos_target_input_name]
+
+    neg_target_node_id = ksampler_id
+    neg_target_input_name = 'negative'
+    if 'negative' not in assembler.workflow[neg_target_node_id]['inputs']:
+        print(f"Warning: KSampler node '{ksampler_name}' has no 'negative' input. Skipping negative ReferenceLatent chain.")
+        neg_target_node_id = None
+    
+    current_neg_conditioning = None
+    if neg_target_node_id:
+        current_neg_conditioning = assembler.workflow[neg_target_node_id]['inputs'][neg_target_input_name]
+
+    for i, img_filename in enumerate(chain_items):
+        load_id = assembler._get_unique_id()
+        load_node = assembler._get_node_template_from_api("LoadImage")
+        load_node['inputs']['image'] = img_filename
+        load_node['_meta']['title'] = f"Load Reference Image {i+1}"
+        assembler.workflow[load_id] = load_node
+        
+        scale_id = assembler._get_unique_id()
+        scale_node = assembler._get_node_template_from_api("ImageScaleToTotalPixels")
+        scale_node['inputs']['megapixels'] = 1.0
+        scale_node['inputs']['upscale_method'] = "lanczos"
+        scale_node['inputs']['image'] = [load_id, 0]
+        scale_node['_meta']['title'] = f"Scale Reference {i+1}"
+        assembler.workflow[scale_id] = scale_node
+        
+        vae_encode_id = assembler._get_unique_id()
+        vae_encode_node = assembler._get_node_template_from_api("VAEEncode")
+        vae_encode_node['inputs']['pixels'] = [scale_id, 0]
+        vae_encode_node['inputs']['vae'] = [vae_node_id, 0]
+        vae_encode_node['_meta']['title'] = f"VAE Encode Reference {i+1}"
+        assembler.workflow[vae_encode_id] = vae_encode_node
+        
+        latent_conn = [vae_encode_id, 0]
+
+        pos_ref_latent_id = assembler._get_unique_id()
+        pos_ref_latent_node = assembler._get_node_template_from_api("ReferenceLatent")
+        pos_ref_latent_node['inputs']['conditioning'] = current_pos_conditioning
+        pos_ref_latent_node['inputs']['latent'] = latent_conn
+        pos_ref_latent_node['_meta']['title'] = f"Positive ReferenceLatent {i+1}"
+        assembler.workflow[pos_ref_latent_id] = pos_ref_latent_node
+        current_pos_conditioning = [pos_ref_latent_id, 0]
+
+        if neg_target_node_id:
+            neg_ref_latent_id = assembler._get_unique_id()
+            neg_ref_latent_node = assembler._get_node_template_from_api("ReferenceLatent")
+            neg_ref_latent_node['inputs']['conditioning'] = current_neg_conditioning
+            neg_ref_latent_node['inputs']['latent'] = latent_conn
+            neg_ref_latent_node['_meta']['title'] = f"Negative ReferenceLatent {i+1}"
+            assembler.workflow[neg_ref_latent_id] = neg_ref_latent_node
+            current_neg_conditioning = [neg_ref_latent_id, 0]
+
+    assembler.workflow[pos_target_node_id]['inputs'][pos_target_input_name] = current_pos_conditioning
+    if neg_target_node_id:
+        assembler.workflow[neg_target_node_id]['inputs'][neg_target_input_name] = current_neg_conditioning
+    
+    print(f"ReferenceLatent injector applied. Re-routed inputs through {len(chain_items)} reference images.")