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,15 +1,9 @@
 import gc
 from typing import Dict, List, Any, Set
-
-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:
     _instance = None
@@ -22,102 +16,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.")
-        
-        with torch.no_grad():
-            _, 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="qwen_image", 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)
-
-            lora_loader = LoraLoader()
-
-            base_lora_name = components.get('lora')
-            if base_lora_name:
-                print(f"--- [ModelManager] Applying base model LoRA: {base_lora_name} ---")
-                _ensure_model_downloaded(base_lora_name, progress)
-                unet_object, clip_object = lora_loader.load_lora(
-                    model=unet_object,
-                    clip=clip_object,
-                    lora_name=base_lora_name,
-                    strength_model=1.0,
-                    strength_clip=1.0
-                )
-                print(f"--- [ModelManager] ✅ Base LoRA merged into the model on CPU. ---")
-
-            if active_loras:
-                print(f"--- [ModelManager] Applying {len(active_loras)} custom LoRAs on CPU... ---")
-                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 custom 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:
-            with torch.no_grad():
-                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} ---")
         
@@ -141,44 +42,5 @@ class ModelManager:
                 raise gr.Error(f"Failed to download model component '{filename}'. Reason: {e}")
 
         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 = self.last_active_loras != 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)
-                print(f"--- [ModelManager] LoRA configuration changed. Reloading base model(s): {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:
-                    self.last_active_loras = []
-                    raise gr.Error(f"Failed to load model combo or apply LoRA for '{display_name}'. Reason: {e}")
-            
-            self.last_active_loras = active_loras
-        else:
-             print(f"--- [ModelManager] All required models are already loaded. ---")
-
-        return {name: self.loaded_models[name] for name in required_models}
 
 model_manager = ModelManager()

core/pipelines/sd_image_pipeline.py

@@ -113,29 +113,13 @@ class SdImagePipeline(BasePipeline):
             
             return get_value_at_index(computed_outputs[image_source_node_id], image_source_index)
 
-    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)):
+    def _gpu_logic(self, ui_inputs: Dict, loras_string: 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)
         
         output_images = []
@@ -170,8 +154,24 @@ class SdImagePipeline(BasePipeline):
         
         self.model_manager.ensure_models_downloaded(required_models, progress=progress)
         
-        lora_data = ui_inputs.get('lora_data', [])
+        model_display_name = ui_inputs['model_display_name']
+        if model_display_name not in ALL_MODEL_MAP:
+            raise gr.Error(f"Model '{model_display_name}' is not configured in model_list.yaml.")
+        
+        _, components, _, _ = ALL_MODEL_MAP[model_display_name]
+        base_lora_name = components.get('lora')
+        
         active_loras_for_gpu, active_loras_for_meta = [], []
+        
+        if base_lora_name:
+            active_loras_for_gpu.append({
+                "lora_name": base_lora_name, 
+                "strength_model": 1.0, 
+                "strength_clip": 1.0
+            })
+            active_loras_for_meta.append(f"Base LoRA {base_lora_name}:1.0")
+
+        lora_data = ui_inputs.get('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)):
@@ -187,9 +187,6 @@ class SdImagePipeline(BasePipeline):
                 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)
@@ -340,12 +337,6 @@ class SdImagePipeline(BasePipeline):
         recipe_path = os.path.join(os.path.dirname(__file__), "workflow_recipes", "sd_unified_recipe.yaml")
         assembler = WorkflowAssembler(recipe_path, dynamic_values=dynamic_values)
         
-        model_display_name = ui_inputs['model_display_name']
-        if model_display_name not in ALL_MODEL_MAP:
-            raise gr.Error(f"Model '{model_display_name}' is not configured in model_list.yaml.")
-        
-        _, components, _, _ = ALL_MODEL_MAP[model_display_name]
-        
         workflow_inputs = {
             "positive_prompt": ui_inputs['positive_prompt'], "negative_prompt": ui_inputs['negative_prompt'],
             "seed": ui_inputs['seed'], "steps": ui_inputs['num_inference_steps'], "cfg": ui_inputs['guidance_scale'],
@@ -361,6 +352,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,
             "conditioning_chain": active_conditioning,
         }
@@ -381,11 +373,47 @@ class SdImagePipeline(BasePipeline):
                 task_name=f"ImageGen ({task_type})",
                 ui_inputs=ui_inputs,
                 loras_string=loras_string,
-                required_models_for_gpu=required_models,
                 workflow=workflow,
                 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/qwen-image.yaml

@@ -48,6 +48,19 @@ connections:
   - from: "neg_prompt:0"
     to: "ksampler:negative"
 
+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_controlnet_chains:
   controlnet_chain:
     template: "ControlNetApplyAdvanced"

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,9 +1,12 @@
 injector_definitions:
+  dynamic_lora_chains: 
+    module: "chain_injectors.lora_injector"
   dynamic_controlnet_chains: 
     module: "chain_injectors.controlnet_injector"
   dynamic_conditioning_chains:
     module: "chain_injectors.conditioning_injector"
   
 injector_order:
+  - dynamic_lora_chains
   - dynamic_conditioning_chains
   - dynamic_controlnet_chains