Upload folder using huggingface_hub

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(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.")

core/model_manager.py

@@ -1,14 +1,10 @@
 import gc
-from typing import Dict, List, Any, Set
+from typing import List
 
-import torch
 import gradio as gr
-from comfy import model_management
 
-from core.settings import ALL_MODEL_MAP, CHECKPOINT_DIR, LORA_DIR, DIFFUSION_MODELS_DIR, VAE_DIR, TEXT_ENCODERS_DIR
-from comfy_integration.nodes import LoraLoader
-from nodes import NODE_CLASS_MAPPINGS
-from utils.app_utils import get_value_at_index, _ensure_model_downloaded
+from core.settings import ALL_MODEL_MAP
+from utils.app_utils import _ensure_model_downloaded
 
 
 class ModelManager:
@@ -22,86 +18,9 @@ class ModelManager:
     def __init__(self):
         if hasattr(self, 'initialized'):
             return
-        self.loaded_models: Dict[str, Any] = {}
-        self.last_active_loras: List[Dict[str, Any]] = []
         self.initialized = True
         print("✅ ModelManager initialized.")
 
-    def get_loaded_model_names(self) -> Set[str]:
-        return set(self.loaded_models.keys())
-
-    def _load_model_combo(self, display_name: str, active_loras: List[Dict[str, Any]], progress) -> Dict[str, Any]:
-        print(f"--- [ModelManager] Loading model combo: '{display_name}' ---")
-        
-        if display_name not in ALL_MODEL_MAP:
-            raise ValueError(f"Model '{display_name}' not found in configuration.")
-            
-        _, components, _, _ = ALL_MODEL_MAP[display_name]
-        
-        unet_filename = components.get('unet')
-        clip_filename = components.get('clip')
-        vae_filename = components.get('vae')
-        
-        if not all([unet_filename, clip_filename, vae_filename]):
-             raise ValueError(f"Model '{display_name}' is missing required components (unet, clip, or vae) in model_list.yaml.")
-
-        unet_loader = NODE_CLASS_MAPPINGS["UNETLoader"]()
-        clip_loader = NODE_CLASS_MAPPINGS["CLIPLoader"]()
-        vae_loader = NODE_CLASS_MAPPINGS["VAELoader"]()
-
-        print("  - Loading UNET...")
-        unet_tuple = unet_loader.load_unet(unet_name=unet_filename, weight_dtype="default")
-        
-        print("  - Loading CLIP...")
-        clip_tuple = clip_loader.load_clip(clip_name=clip_filename, type="lumina2", device="default")
-        
-        print("  - Loading VAE...")
-        vae_tuple = vae_loader.load_vae(vae_name=vae_filename)
-        
-        unet_object = get_value_at_index(unet_tuple, 0)
-        clip_object = get_value_at_index(clip_tuple, 0)
-
-        if active_loras:
-            print(f"--- [ModelManager] Applying {len(active_loras)} LoRAs on CPU... ---")
-            lora_loader = LoraLoader()
-            patched_unet, patched_clip = unet_object, clip_object
-
-            for lora_info in active_loras:
-                patched_unet, patched_clip = lora_loader.load_lora(
-                    model=patched_unet,
-                    clip=patched_clip,
-                    lora_name=lora_info["lora_name"],
-                    strength_model=lora_info["strength_model"],
-                    strength_clip=lora_info["strength_clip"]
-                )
-            
-            unet_object = patched_unet
-            clip_object = patched_clip
-            print(f"--- [ModelManager] ✅ All LoRAs merged into the model on CPU. ---")
-            
-        loaded_combo = {
-            "unet": (unet_object,),
-            "clip": (clip_object,),
-            "vae": vae_tuple,
-        }
-        
-        print(f"--- [ModelManager] ✅ Successfully loaded combo '{display_name}' to CPU/RAM ---")
-        return loaded_combo
-
-    def move_models_to_gpu(self, required_models: List[str]):
-        print(f"--- [ModelManager] Moving models to GPU: {required_models} ---")
-        models_to_load_gpu = []
-        for name in required_models:
-            if name in self.loaded_models:
-                model_combo = self.loaded_models[name]
-                models_to_load_gpu.append(get_value_at_index(model_combo.get("unet"), 0))
-
-        if models_to_load_gpu:
-            model_management.load_models_gpu(models_to_load_gpu)
-            print("--- [ModelManager] ✅ Models successfully moved to GPU. ---")
-        else:
-            print("--- [ModelManager] ⚠️ No component models found to move to GPU. ---")
-
     def ensure_models_downloaded(self, required_models: List[str], progress):
         print(f"--- [ModelManager] Ensuring models are downloaded: {required_models} ---")
         
@@ -109,8 +28,9 @@ class ModelManager:
         for display_name in required_models:
             if display_name in ALL_MODEL_MAP:
                 _, components, _, _ = ALL_MODEL_MAP[display_name]
-                for component_file in components.values():
-                    files_to_download.add(component_file)
+                for component_key, component_file in components.items():
+                    if component_key in ['unet', 'clip', 'vae', 'lora']:
+                        files_to_download.add(component_file)
         
         files_to_download = list(files_to_download)
         total_files = len(files_to_download)
@@ -125,44 +45,4 @@ class ModelManager:
 
         print(f"--- [ModelManager] ✅ All required models are present on disk. ---")
     
-    def load_managed_models(self, required_models: List[str], active_loras: List[Dict[str, Any]], progress) -> Dict[str, Any]:
-        required_set = set(required_models)
-        current_set = set(self.loaded_models.keys())
-
-        loras_changed = active_loras != self.last_active_loras
-
-        models_to_unload = current_set - required_set
-        if models_to_unload or loras_changed:
-            if models_to_unload:
-                print(f"--- [ModelManager] Models to unload: {models_to_unload} ---")
-            if loras_changed and not models_to_unload:
-                models_to_unload = current_set.intersection(required_set)
-                if active_loras:
-                    print(f"--- [ModelManager] LoRA configuration changed. Reloading base model(s): {models_to_unload} ---")
-                else:
-                    print(f"--- [ModelManager] LoRAs removed. Reloading base model(s) to clear patches: {models_to_unload} ---")
-                
-            model_management.unload_all_models()
-            self.loaded_models.clear()
-            gc.collect()
-            torch.cuda.empty_cache()
-            print("--- [ModelManager] All models unloaded to free RAM. ---")
-        
-        models_to_load = required_set if (models_to_unload or loras_changed) else required_set - current_set
-        
-        if models_to_load:
-            print(f"--- [ModelManager] Models to load: {models_to_load} ---")
-            for i, display_name in enumerate(models_to_load):
-                progress(i / len(models_to_load), desc=f"Loading model: {display_name}")
-                try:
-                    loaded_model_data = self._load_model_combo(display_name, active_loras, progress)
-                    self.loaded_models[display_name] = loaded_model_data
-                except Exception as e:
-                    raise gr.Error(f"Failed to load model combo or apply LoRA for '{display_name}'. Reason: {e}")
-        else:
-             print(f"--- [ModelManager] All required models are already loaded. ---")
-
-        self.last_active_loras = active_loras
-        return {name: self.loaded_models[name] for name in required_models}
-
 model_manager = ModelManager()

core/pipelines/sd_image_pipeline.py

@@ -116,25 +116,9 @@ class SdImagePipeline(BasePipeline):
     def _gpu_logic(self, ui_inputs: Dict, loras_string: str, required_models_for_gpu: List[str], workflow: Dict[str, Any], assembler: WorkflowAssembler, progress=gr.Progress(track_tqdm=True)):
         model_display_name = ui_inputs['model_display_name']
         
-        progress(0.1, desc="Moving models to GPU...")
-        self.model_manager.move_models_to_gpu(required_models_for_gpu)
-        
         progress(0.4, desc="Executing workflow...")
         
-        loaded_model_combo = self.model_manager.loaded_models[model_display_name]
-        
         initial_objects = {}
-        
-        unet_loader_id = assembler.node_map.get("unet_loader")
-        clip_loader_id = assembler.node_map.get("clip_loader")
-        vae_loader_id = assembler.node_map.get("vae_loader")
-
-        if unet_loader_id: initial_objects[unet_loader_id] = loaded_model_combo.get("unet")
-        if clip_loader_id: initial_objects[clip_loader_id] = loaded_model_combo.get("clip")
-        if vae_loader_id: initial_objects[vae_loader_id] = loaded_model_combo.get("vae")
-
-        if not all([unet_loader_id, clip_loader_id, vae_loader_id]):
-            raise RuntimeError("Workflow is missing one or more required loaders (unet_loader, clip_loader, vae_loader).")
             
         decoded_images_tensor = self._execute_workflow(workflow, initial_objects=initial_objects)
         
@@ -172,25 +156,24 @@ class SdImagePipeline(BasePipeline):
         
         lora_data = ui_inputs.get('lora_data', [])
         active_loras_for_gpu, active_loras_for_meta = [], []
-        sources, ids, scales, files = lora_data[0::4], lora_data[1::4], lora_data[2::4], lora_data[3::4]
         
-        for i, (source, lora_id, scale, _) in enumerate(zip(sources, ids, scales, files)):
-            if scale > 0 and lora_id and lora_id.strip():
-                lora_filename = None
-                if source == "File":
-                    lora_filename = sanitize_filename(lora_id)
-                elif source == "Civitai":
-                    local_path, status = get_lora_path(source, lora_id, ui_inputs['civitai_api_key'], progress)
-                    if local_path: lora_filename = os.path.basename(local_path)
-                    else: raise gr.Error(f"Failed to prepare LoRA {lora_id}: {status}")
-                
-                if lora_filename:
-                    active_loras_for_gpu.append({"lora_name": lora_filename, "strength_model": scale, "strength_clip": scale})
-                    active_loras_for_meta.append(f"{source} {lora_id}:{scale}")
+        if lora_data:
+            sources, ids, scales, files = lora_data[0::4], lora_data[1::4], lora_data[2::4], lora_data[3::4]
+            
+            for i, (source, lora_id, scale, _) in enumerate(zip(sources, ids, scales, files)):
+                if scale > 0 and lora_id and lora_id.strip():
+                    lora_filename = None
+                    if source == "File":
+                        lora_filename = sanitize_filename(lora_id)
+                    elif source == "Civitai":
+                        local_path, status = get_lora_path(source, lora_id, ui_inputs['civitai_api_key'], progress)
+                        if local_path: lora_filename = os.path.basename(local_path)
+                        else: raise gr.Error(f"Failed to prepare LoRA {lora_id}: {status}")
+                    
+                    if lora_filename:
+                        active_loras_for_gpu.append({"lora_name": lora_filename, "strength_model": scale, "strength_clip": scale})
+                        active_loras_for_meta.append(f"{source} {lora_id}:{scale}")
         
-        progress(0.1, desc="Loading models into RAM...")
-        self.model_manager.load_managed_models(required_models, active_loras=active_loras_for_gpu, progress=progress)
-
         ui_inputs['denoise'] = 1.0
         if task_type == 'img2img': ui_inputs['denoise'] = ui_inputs.get('img2img_denoise', 0.7)
         elif task_type == 'hires_fix': ui_inputs['denoise'] = ui_inputs.get('hires_denoise', 0.55)
@@ -275,19 +258,20 @@ class SdImagePipeline(BasePipeline):
 
         controlnet_data = ui_inputs.get('controlnet_data', [])
         active_controlnets = []
-        (cn_images, _, _, cn_strengths, cn_filepaths) = [controlnet_data[i::5] for i in range(5)]
-        for i in range(len(cn_images)):
-            if cn_images[i] and cn_strengths[i] > 0 and cn_filepaths[i] and cn_filepaths[i] != "None":
-                ensure_controlnet_model_downloaded(cn_filepaths[i], progress)
-
-                if not os.path.exists(INPUT_DIR): os.makedirs(INPUT_DIR)
-                cn_temp_path = os.path.join(INPUT_DIR, f"temp_cn_{i}_{random.randint(1000, 9999)}.png")
-                cn_images[i].save(cn_temp_path, "PNG")
-                temp_files_to_clean.append(cn_temp_path)
-                active_controlnets.append({
-                    "image": os.path.basename(cn_temp_path), "strength": cn_strengths[i],
-                    "start_percent": 0.0, "end_percent": 1.0, "control_net_name": cn_filepaths[i]
-                })
+        if controlnet_data:
+            (cn_images, _, _, cn_strengths, cn_filepaths) = [controlnet_data[i::5] for i in range(5)]
+            for i in range(len(cn_images)):
+                if cn_images[i] and cn_strengths[i] > 0 and cn_filepaths[i] and cn_filepaths[i] != "None":
+                    ensure_controlnet_model_downloaded(cn_filepaths[i], progress)
+
+                    if not os.path.exists(INPUT_DIR): os.makedirs(INPUT_DIR)
+                    cn_temp_path = os.path.join(INPUT_DIR, f"temp_cn_{i}_{random.randint(1000, 9999)}.png")
+                    cn_images[i].save(cn_temp_path, "PNG")
+                    temp_files_to_clean.append(cn_temp_path)
+                    active_controlnets.append({
+                        "image": os.path.basename(cn_temp_path), "strength": cn_strengths[i],
+                        "start_percent": 0.0, "end_percent": 1.0, "control_net_name": cn_filepaths[i]
+                    })
         
         diffsynth_controlnet_data = ui_inputs.get('diffsynth_controlnet_data', [])
         active_diffsynth_controlnets = []
@@ -378,6 +362,7 @@ class SdImagePipeline(BasePipeline):
             "unet_name": components['unet'],
             "clip_name": components['clip'],
             "vae_name": ui_inputs.get('vae_name', components['vae']),
+            "lora_chain": active_loras_for_gpu,
             "controlnet_chain": active_controlnets,
             "diffsynth_controlnet_chain": active_diffsynth_controlnets,
             "conditioning_chain": active_conditioning,
@@ -404,6 +389,43 @@ class SdImagePipeline(BasePipeline):
                 assembler=assembler, 
                 progress=progress
             )
+            
+            import json
+            import glob
+            from PIL import PngImagePlugin
+            
+            prompt_json = json.dumps(workflow)
+            
+            out_dir = os.path.abspath(OUTPUT_DIR)
+            os.makedirs(out_dir, exist_ok=True)
+            
+            try:
+                existing_files = glob.glob(os.path.join(out_dir, "gen_*.png"))
+                existing_files.sort(key=os.path.getmtime)
+                while len(existing_files) > 50:
+                    os.remove(existing_files.pop(0))
+            except Exception as e:
+                print(f"Warning: Failed to cleanup output dir: {e}")
+
+            final_results = []
+            for img in results:
+                if not isinstance(img, Image.Image):
+                    final_results.append(img)
+                    continue
+                    
+                metadata = PngImagePlugin.PngInfo()
+                params_string = img.info.get("parameters", "")
+                if params_string:
+                    metadata.add_text("parameters", params_string)
+                metadata.add_text("prompt", prompt_json)
+                
+                filename = f"gen_{random.randint(1000000, 9999999)}.png"
+                filepath = os.path.join(out_dir, filename)
+                img.save(filepath, "PNG", pnginfo=metadata)
+                final_results.append(filepath)
+            
+            results = final_results
+
         finally:
             for temp_file in temp_files_to_clean:
                 if temp_file and os.path.exists(temp_file):

core/pipelines/workflow_recipes/_partials/conditioning/z-image.yaml

@@ -45,6 +45,19 @@ connections:
   - from: "vae_loader:0"
     to: "vae_encode:vae"
 
+dynamic_lora_chains:
+  lora_chain:
+    template: "LoraLoader"
+    output_map:
+      "unet_loader:0": "model"
+      "clip_loader:0": "clip"
+    input_map:
+      "model": "model"
+      "clip": "clip"
+    end_input_map:
+      "model": ["model_sampler:model"]
+      "clip": ["pos_prompt:clip", "neg_prompt:clip"]
+
 dynamic_diffsynth_controlnet_chains:
   diffsynth_controlnet_chain:
     template: "QwenImageDiffsynthControlnet"

requirements.txt

@@ -1,5 +1,5 @@
-comfyui-frontend-package==1.41.20
-comfyui-workflow-templates==0.9.21
+comfyui-frontend-package==1.42.10
+comfyui-workflow-templates==0.9.47
 comfyui-embedded-docs==0.4.3
 torch
 torchsde

yaml/injectors.yaml

@@ -1,4 +1,6 @@
 injector_definitions:
+  dynamic_lora_chains: 
+    module: "chain_injectors.lora_injector"
   dynamic_controlnet_chains: 
     module: "chain_injectors.controlnet_injector"
   dynamic_diffsynth_controlnet_chains:
@@ -7,6 +9,7 @@ injector_definitions:
     module: "chain_injectors.conditioning_injector"
   
 injector_order:
+  - dynamic_lora_chains
   - dynamic_conditioning_chains
   - dynamic_diffsynth_controlnet_chains
   - dynamic_controlnet_chains