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
+from typing import List
 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 checkpointloadersimple, 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,59 +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_single_model(self, display_name: str, progress) -> Any:
-        print(f"--- [ModelManager] Loading model: '{display_name}' ---")
-        
-        filename = _ensure_model_downloaded(display_name, progress)
-        
-        _, _, model_type, _ = ALL_MODEL_MAP[display_name]
-        
-        loader_map = {
-            "SDXL": (checkpointloadersimple, "load_checkpoint", {"ckpt_name": filename}),
-            "SD1.5": (checkpointloadersimple, "load_checkpoint", {"ckpt_name": filename}),
-            "UNET": (NODE_CLASS_MAPPINGS["UNETLoader"](), "load_unet", {"unet_name": filename, "weight_dtype": "default"}),
-            "VAE": (NODE_CLASS_MAPPINGS["VAELoader"](), "load_vae", {"vae_name": filename}),
-            "TEXT_ENCODER": (NODE_CLASS_MAPPINGS["CLIPLoader"](), "load_clip", {"clip_name": filename, "type": "wan", "device": "default"}),
-        }
-
-        if model_type not in loader_map:
-            if model_type == "LORA":
-                print(f"--- [ModelManager] ✅ '{display_name}' is a LoRA. It will be loaded dynamically. ---")
-                return (filename,)
-            raise ValueError(f"[ModelManager] No loader configured for model type '{model_type}'")
-
-        loader_instance, method_name, kwargs = loader_map[model_type]
-        
-        load_method = getattr(loader_instance, method_name)
-        loaded_tuple = load_method(**kwargs)
-
-        print(f"--- [ModelManager] ✅ Successfully loaded '{display_name}' to CPU/RAM ---")
-        return loaded_tuple
-
-    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_tuple = self.loaded_models[name]
-                _, _, model_type, _ = ALL_MODEL_MAP[name]
-                if model_type in ["SDXL", "SD1.5"]:
-                     models_to_load_gpu.append(get_value_at_index(model_tuple, 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 checkpoint 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} ---")
         for i, display_name in enumerate(required_models):
@@ -85,61 +29,5 @@ class ModelManager:
             except Exception as e:
                 raise gr.Error(f"Failed to download model '{display_name}'. 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
-        
-        must_reload = bool(models_to_unload) or loras_changed
-
-        if must_reload:
-            if models_to_unload:
-                print(f"--- [ModelManager] Models to unload: {models_to_unload} ---")
-            if loras_changed and not models_to_unload:
-                print(f"--- [ModelManager] LoRA configuration changed. Reloading base model(s): {current_set.intersection(required_set)} ---")
-                
-            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 must_reload 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_single_model(display_name, progress)
-                    
-                    if active_loras and ALL_MODEL_MAP[display_name][2] in ["SDXL", "SD1.5"]:
-                        print(f"--- [ModelManager] Applying {len(active_loras)} LoRAs on CPU... ---")
-                        lora_loader = LoraLoader()
-                        patched_model, patched_clip = loaded_model_data[0], loaded_model_data[1]
-
-                        for lora_info in active_loras:
-                            patched_model, patched_clip = lora_loader.load_lora(
-                                model=patched_model,
-                                clip=patched_clip,
-                                lora_name=lora_info["lora_name"],
-                                strength_model=lora_info["strength_model"],
-                                strength_clip=lora_info["strength_clip"]
-                            )
-                        
-                        loaded_model_data = (patched_model, patched_clip, loaded_model_data[2])
-                        print(f"--- [ModelManager] ✅ All LoRAs merged into the model on CPU. ---")
-                    
-                    self.loaded_models[display_name] = loaded_model_data
-                except Exception as e:
-                    raise gr.Error(f"Failed to load model or apply LoRA '{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

@@ -47,7 +47,6 @@ class SdImagePipeline(BasePipeline):
             
         return sorted_nodes
 
-
     def _execute_workflow(self, workflow: Dict[str, Any], initial_objects: Dict[str, Any]):
         with torch.no_grad():
             computed_outputs = initial_objects
@@ -71,6 +70,10 @@ class SdImagePipeline(BasePipeline):
                 node_info = workflow[node_id]
                 class_type = node_info['class_type']
                 
+                is_loader_with_filename = 'Loader' in class_type and any(key.endswith('_name') for key in node_info['inputs'])
+                if node_id in initial_objects and is_loader_with_filename:
+                    continue
+                
                 node_class = NODE_CLASS_MAPPINGS.get(class_type)
                 if node_class is None:
                      raise RuntimeError(f"Could not find node class '{class_type}'. Is it imported in comfy_integration/nodes.py?")
@@ -109,23 +112,12 @@ 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_tuple = self.model_manager.loaded_models[model_display_name]
-        
-        ckpt_loader_node_id = assembler.node_map.get("ckpt_loader")
-        if not ckpt_loader_node_id:
-            raise RuntimeError("Workflow is missing the 'ckpt_loader' node required for model injection.")
-        
-        initial_objects = {
-            ckpt_loader_node_id: loaded_model_tuple
-        }
+        initial_objects = {}
         
         decoded_images_tensor = self._execute_workflow(workflow, initial_objects=initial_objects)
         
@@ -163,24 +155,22 @@ 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}")
-        
-        progress(0.1, desc="Loading models into RAM...")
-        self.model_manager.load_managed_models(required_models, active_loras=active_loras_for_gpu, progress=progress)
+        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}")
 
         ui_inputs['denoise'] = 1.0
         if task_type == 'img2img': ui_inputs['denoise'] = ui_inputs.get('img2img_denoise', 0.7)
@@ -380,6 +370,7 @@ class SdImagePipeline(BasePipeline):
             "hires_upscaler": ui_inputs.get('hires_upscaler'), "hires_scale_by": ui_inputs.get('hires_scale_by'),
             "model_name": ALL_MODEL_MAP[ui_inputs['model_display_name']][1],
             "vae_name": ui_inputs.get('vae_name'),
+            "lora_chain": active_loras_for_gpu,
             "controlnet_chain": active_controlnets,
             "ipadapter_chain": active_ipadapters,
             "conditioning_chain": active_conditioning,
@@ -420,11 +411,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/sdxl.yaml

@@ -32,6 +32,19 @@ ui_map:
   positive_prompt: "pos_prompt:text"
   negative_prompt: "neg_prompt:text"
   
+dynamic_lora_chains:
+  lora_chain:
+    template: "LoraLoader"
+    output_map:
+      "ckpt_loader:0": "model"
+      "ckpt_loader:1": "clip"
+    input_map:
+      "model": "model"
+      "clip": "clip"
+    end_input_map:
+      "model": ["ksampler:model"]
+      "clip": ["pos_prompt:clip", "neg_prompt:clip"]
+
 dynamic_controlnet_chains:
   controlnet_chain:
     template: "ControlNetApplyAdvanced"

core/settings.py

@@ -106,12 +106,11 @@ try:
     MAX_IPADAPTERS = _constants.get('MAX_IPADAPTERS', 5)
     LORA_SOURCE_CHOICES = _constants.get('LORA_SOURCE_CHOICES', ["Civitai", "Custom URL", "File"])
     RESOLUTION_MAP = _constants.get('RESOLUTION_MAP', {})
-    SAMPLER_MAP = _constants.get('SAMPLER_MAP', {})
 except Exception as e:
     print(f"FATAL: Could not load constants from YAML. Error: {e}")
     MAX_LORAS, MAX_EMBEDDINGS, MAX_CONDITIONINGS, MAX_CONTROLNETS, MAX_IPADAPTERS = 5, 5, 10, 5, 5
     LORA_SOURCE_CHOICES = ["Civitai", "Custom URL", "File"]
-    RESOLUTION_MAP, SAMPLER_MAP = {}, {}
+    RESOLUTION_MAP = {}
 
 
 DEFAULT_NEGATIVE_PROMPT = "monochrome, (low quality, worst quality:1.2), 3d, watermark, signature, ugly, poorly drawn,"

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

ui/events.py

@@ -42,85 +42,6 @@ def load_ipadapter_config():
         return {}
 
 
-def apply_data_to_ui(data, prefix, ui_components):
-    final_sampler = data.get('sampler') if data.get('sampler') in SAMPLER_CHOICES else SAMPLER_CHOICES[0]
-    default_scheduler = 'normal' if 'normal' in SCHEDULER_CHOICES else SCHEDULER_CHOICES[0]
-    final_scheduler = data.get('scheduler') if data.get('scheduler') in SCHEDULER_CHOICES else default_scheduler
-
-    updates = {}
-    base_model_name = data.get('base_model')
-    
-    model_map = MODEL_MAP_CHECKPOINT
-
-    if f'base_model_{prefix}' in ui_components:
-        model_dropdown_component = ui_components[f'base_model_{prefix}']
-        if base_model_name and base_model_name in model_map:
-            updates[model_dropdown_component] = base_model_name
-        else:
-            updates[model_dropdown_component] = gr.update()
-    
-    common_params = {
-        f'prompt_{prefix}': data.get('prompt', ''),
-        f'neg_prompt_{prefix}': data.get('negative_prompt', ''),
-        f'seed_{prefix}': data.get('seed', -1),
-        f'cfg_{prefix}': data.get('cfg_scale', 7.5),
-        f'steps_{prefix}': data.get('steps', 28),
-        f'sampler_{prefix}': final_sampler,
-        f'scheduler_{prefix}': final_scheduler,
-    }
-    
-    for comp_name, value in common_params.items():
-        if comp_name in ui_components:
-            updates[ui_components[comp_name]] = value
-    
-    if prefix == 'txt2img':
-         if f'width_{prefix}' in ui_components:
-             updates[ui_components[f'width_{prefix}']] = data.get('width', 1024)
-         if f'height_{prefix}' in ui_components:
-             updates[ui_components[f'height_{prefix}']] = data.get('height', 1024)
-
-    tab_indices = {"txt2img": 0, "img2img": 1, "inpaint": 2, "outpaint": 3, "hires_fix": 4}
-    tab_index = tab_indices.get(prefix, 0)
-
-    updates[ui_components['tabs']] = gr.Tabs(selected=0)
-    updates[ui_components['image_gen_tabs']] = gr.Tabs(selected=tab_index)
-    
-    return updates
-
-
-def send_info_to_tab(image, prefix, ui_components):
-    if not image or not image.info.get('parameters', ''):
-        all_comps = [comp for comp_or_list in ui_components.values() for comp in (comp_or_list if isinstance(comp_or_list, list) else [comp_or_list])]
-        return {comp: gr.update() for comp in all_comps}
-    
-    data = parse_parameters(image.info['parameters'])
-    
-    image_input_map = {
-        "img2img": 'input_image_img2img',
-        "inpaint": 'input_image_dict_inpaint',
-        "outpaint": 'input_image_outpaint',
-        "hires_fix": 'input_image_hires_fix'
-    }
-    
-    updates = apply_data_to_ui(data, prefix, ui_components)
-    
-    if prefix in image_input_map and image_input_map[prefix] in ui_components:
-        component_key = image_input_map[prefix]
-        updates[ui_components[component_key]] = gr.update(value=image)
-        
-    return updates
-
-
-def send_info_by_hash(image, ui_components):
-    if not image or not image.info.get('parameters', ''):
-        all_comps = [comp for comp_or_list in ui_components.values() for comp in (comp_or_list if isinstance(comp_or_list, list) else [comp_or_list])]
-        return {comp: gr.update() for comp in all_comps}
-
-    data = parse_parameters(image.info['parameters'])
-    
-    return apply_data_to_ui(data, "txt2img", ui_components)
-
-
 def attach_event_handlers(ui_components, demo):
     def update_cn_input_visibility(choice):
         return {
@@ -615,21 +536,6 @@ def attach_event_handlers(ui_components, demo):
 
         create_run_event(prefix, task_type)
 
-
-    ui_components["info_get_button"].click(
-        get_png_info, 
-        [ui_components["info_image_input"]], 
-        [ui_components["info_prompt_output"], ui_components["info_neg_prompt_output"], ui_components["info_params_output"]]
-    )
-
-    flat_ui_list = [comp for comp_or_list in ui_components.values() for comp in (comp_or_list if isinstance(comp_or_list, list) else [comp_or_list])]
-            
-    ui_components["send_to_txt2img_button"].click(lambda img: send_info_by_hash(img, ui_components), [ui_components["info_image_input"]], flat_ui_list)
-    ui_components["send_to_img2img_button"].click(lambda img: send_info_to_tab(img, "img2img", ui_components), [ui_components["info_image_input"]], flat_ui_list)
-    ui_components["send_to_inpaint_button"].click(lambda img: send_info_to_tab(img, "inpaint", ui_components), [ui_components["info_image_input"]], flat_ui_list)
-    ui_components["send_to_outpaint_button"].click(lambda img: send_info_to_tab(img, "outpaint", ui_components), [ui_components["info_image_input"]], flat_ui_list)
-    ui_components["send_to_hires_fix_button"].click(lambda img: send_info_to_tab(img, "hires_fix", ui_components), [ui_components["info_image_input"]], flat_ui_list)
-
     def on_aspect_ratio_change(ratio_key, model_display_name):
         model_type = MODEL_TYPE_MAP.get(model_display_name, 'sdxl').lower()
         res_map = RESOLUTION_MAP.get(model_type, RESOLUTION_MAP.get("sdxl", {}))
@@ -765,7 +671,8 @@ def attach_event_handlers(ui_components, demo):
         ui_components["zero_gpu_cn"]
     ])
     
-    demo.load(
-        fn=run_on_load,
-        outputs=all_load_outputs
-    )
+    if all_load_outputs:
+        demo.load(
+            fn=run_on_load,
+            outputs=all_load_outputs
+        )

ui/layout.py

@@ -28,10 +28,10 @@ def build_ui(event_handler_function):
             "[FLUX.2](https://huggingface.co/spaces/RioShiina/ImageGen-FLUX.2), "
             "[Z-Image](https://huggingface.co/spaces/RioShiina/ImageGen-Z-Image), "
             "[Qwen-Image](https://huggingface.co/spaces/RioShiina/ImageGen-Qwen-Image), "
+            "[Anima](https://huggingface.co/spaces/RioShiina/ImageGen-Anima), "
             "[Illstrious](https://huggingface.co/spaces/RioShiina/ImageGen-Illstrious), "
             "[NoobAI](https://huggingface.co/spaces/RioShiina/ImageGen-NoobAI), "
-            "[SDXL](https://huggingface.co/spaces/RioShiina/ImageGen-SDXL), "
-            "[SD1.5](https://huggingface.co/spaces/RioShiina/ImageGen-SD15)"
+            "[SDXL](https://huggingface.co/spaces/RioShiina/ImageGen-SDXL)"
         )
         with gr.Tabs(elem_id="tabs_container") as tabs:
             with gr.TabItem("Pony", id=0):
@@ -82,31 +82,6 @@ def build_ui(event_handler_function):
                     "cn_dropdowns": cn_dropdowns, "cn_checkboxes": cn_checkboxes
                 })
             
-            with gr.TabItem("PNG Info", id=2):
-                with gr.Column():
-                    info_image_input = gr.Image(type="pil", label="Upload Image", height=512)
-                    with gr.Row():
-                        info_get_button = gr.Button("Get Info")
-                        send_to_txt2img_button = gr.Button("Send to Txt2Img", variant="primary")
-                    with gr.Row():
-                        send_to_img2img_button = gr.Button("Send to Img2Img")
-                        send_to_inpaint_button = gr.Button("Send to Inpaint")
-                        send_to_outpaint_button = gr.Button("Send to Outpaint")
-                        send_to_hires_fix_button = gr.Button("Send to Hires. Fix")
-                    gr.Markdown("### Positive Prompt"); info_prompt_output = gr.Textbox(lines=3, interactive=False, show_label=False)
-                    gr.Markdown("### Negative Prompt"); info_neg_prompt_output = gr.Textbox(lines=3, interactive=False, show_label=False)
-                    gr.Markdown("### Other Parameters"); info_params_output = gr.Textbox(lines=5, interactive=False, show_label=False)
-                ui_components.update({
-                    "info_image_input": info_image_input, "info_get_button": info_get_button,
-                    "send_to_txt2img_button": send_to_txt2img_button,
-                    "send_to_img2img_button": send_to_img2img_button,
-                    "send_to_inpaint_button": send_to_inpaint_button,
-                    "send_to_outpaint_button": send_to_outpaint_button,
-                    "send_to_hires_fix_button": send_to_hires_fix_button,
-                    "info_prompt_output": info_prompt_output, "info_neg_prompt_output": info_neg_prompt_output,
-                    "info_params_output": info_params_output
-                })
-
             ui_components["tabs"] = tabs
         
         gr.Markdown("<div style='text-align: center; margin-top: 20px;'>Made by RioShiina with ❤️<br><a href='https://github.com/RioShiina47' target='_blank'>GitHub</a> | <a href='https://huggingface.co/RioShiina' target='_blank'>Hugging Face</a> | <a href='https://civitai.com/user/RioShiina' target='_blank'>Civitai</a></div>")

utils/app_utils.py

@@ -482,43 +482,6 @@ def ensure_ipadapter_models_downloaded(preset_name: str, progress):
             print(f"❌ Error ensuring download for IPAdapter asset '{filename}': {e}")
 
 
-def parse_parameters(params_text: str) -> dict:
-    data = {}
-    lines = params_text.strip().split('\n')
-    data['prompt'] = lines[0]
-    data['negative_prompt'] = lines[1].replace("Negative prompt:", "").strip() if len(lines) > 1 and lines[1].startswith("Negative prompt:") else ""
-    
-    params_line = '\n'.join(lines[2:])
-
-    def find_param(key, default, cast_type=str):
-        match = re.search(fr"\b{key}: ([^,]+?)(,|$|\n)", params_line)
-        return cast_type(match.group(1).strip()) if match else default
-
-    data['steps'] = find_param("Steps", 28, int)
-    data['sampler'] = find_param("Sampler", "euler", str)
-    data['scheduler'] = find_param("Scheduler", "normal", str)
-    data['cfg_scale'] = find_param("CFG scale", 7.5, float)
-    data['seed'] = find_param("Seed", -1, int)
-    data['clip_skip'] = find_param("Clip skip", 1, int)
-    data['base_model'] = find_param("Base Model", list(ALL_MODEL_MAP.keys())[0] if ALL_MODEL_MAP else "", str)
-    data['model_hash'] = find_param("Model hash", None, str)
-    
-    size_match = re.search(r"Size: (\d+)x(\d+)", params_line)
-    data['width'], data['height'] = (int(size_match.group(1)), int(size_match.group(2))) if size_match else (1024, 1024)
-    
-    return data
-
-def get_png_info(image) -> tuple[str, str, str]:
-    if not image or not (params := image.info.get('parameters')):
-        return "", "", "No metadata found in the image."
-    
-    parsed_data = parse_parameters(params)
-    raw_params_list = '\n'.join(params.strip().split('\n')[2:]).split(',')
-    other_params_text = "\n".join([p.strip() for p in raw_params_list])
-    
-    return parsed_data.get('prompt', ''), parsed_data.get('negative_prompt', ''), other_params_text
-
-
 def build_preprocessor_model_map():
     global PREPROCESSOR_MODEL_MAP
     if PREPROCESSOR_MODEL_MAP is not None: return PREPROCESSOR_MODEL_MAP

yaml/constants.yaml

@@ -13,20 +13,4 @@ RESOLUTION_MAP:
     "4:3 (Classic)": [1152, 896]
     "3:4 (Classic Portrait)": [896, 1152]
     "3:2 (Photography)": [1216, 832]
-    "2:3 (Photography Portrait)": [832, 1216]
-
-SAMPLER_MAP:
-  euler a: "euler_ancestral"
-  dpm++ 2s a: "dpmpp_2s_ancestral"
-  dpm++ 2m: "dpmpp_2m"
-  dpm++ sde: "dpmpp_sde"
-  dpm++ 2m sde: "dpmpp_2m_sde"
-  dpm++ 3m sde: "dpmpp_3m_sde"
-  ddim: "ddim"
-  uni_pc: "uni_pc"
-  euler_a: "euler_ancestral"
-  dpm++ 2s a karras: "dpmpp_2s_ancestral"
-  dpm++ 2m karras: "dpmpp_2m"
-  dpm++ sde karras: "dpmpp_sde"
-  dpm++ 2m sde karras: "dpmpp_2m_sde"
-  dpm++ 3m sde karras: "dpmpp_3m_sde"
+    "2:3 (Photography Portrait)": [832, 1216]

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_ipadapter_chains:
@@ -7,6 +9,7 @@ injector_definitions:
     module: "chain_injectors.conditioning_injector"
   
 injector_order:
+  - dynamic_lora_chains
   - dynamic_ipadapter_chains
   - dynamic_conditioning_chains
   - dynamic_controlnet_chains