import os import re import yaml from copy import deepcopy from comfy_integration.nodes import NODE_CLASS_MAPPINGS from chain_injectors import discover_injectors, get_registered_features from core.settings import FEATURES_CONFIG _PLACEHOLDER_RE = re.compile(r"\{\{\s*(\w+)\s*\}\}") def _render_placeholders(text: str, values: dict) -> str: for key, val in (values or {}).items(): if val is not None: text = text.replace(f"{{{{ {key} }}}}", str(val)) return text def _merge_recipe_dict(target: dict, source: dict) -> dict: for key, val in (source or {}).items(): if key == "imports" or val is None: continue if key == "connections" and isinstance(val, list): target.setdefault("connections", []).extend(val) elif isinstance(val, dict): target.setdefault(key, {}).update(val) else: target[key] = val return target def _iter_ui_bindings(ui_map: dict, ui_values: dict): for ui_key, target in (ui_map or {}).items(): if isinstance(target, dict): sub_src = ui_values.get(ui_key) if isinstance(ui_values.get(ui_key), dict) else {} for sub_key, sub_targets in target.items(): val = sub_src.get(sub_key) if sub_src.get(sub_key) is not None else ui_values.get(sub_key) if val is not None: for spec in (sub_targets if isinstance(sub_targets, list) else [sub_targets]): if isinstance(spec, str) and ":" in spec: yield (*spec.split(":", 1), val) elif (val := ui_values.get(ui_key)) is not None: for spec in (target if isinstance(target, list) else [target]): if isinstance(spec, str) and ":" in spec: yield (*spec.split(":", 1), val) class WorkflowAssembler: def __init__(self, recipe_path, dynamic_values=None): self.base_path = os.path.dirname(recipe_path) self.dynamic_values = dynamic_values or {} self.node_counter = 0 self.workflow = {} self.node_map = {} self._load_injector_config(model_type=self.dynamic_values.get("model_type")) self.recipe = self._load_and_merge_recipe(os.path.basename(recipe_path), self.dynamic_values) def _load_injector_config(self, model_type=None): self.global_injectors = discover_injectors() registered_features = get_registered_features() order = [] if model_type and model_type in FEATURES_CONFIG: for feat in FEATURES_CONFIG[model_type].get("enabled_chains", []): chain_key = ( registered_features[feat]["chain_type"] if feat in registered_features else f"dynamic_{feat}_chains" ) if chain_key in self.global_injectors and chain_key not in order: order.append(chain_key) for chain_key in self.global_injectors: if chain_key not in order: order.append(chain_key) for chain_key in list(order): func = self.global_injectors.get(chain_key) if not func: continue feature = chain_key[8:-7] if (chain_key.startswith("dynamic_") and chain_key.endswith("_chains")) else chain_key alias = f"dynamic_{feature}_chains" self.global_injectors.setdefault(alias, func) self.global_injectors.setdefault(feature, func) if alias not in order: order.append(alias) if feature not in order: order.append(feature) self.injector_order = order def _get_unique_id(self): self.node_counter += 1 return str(self.node_counter) def _get_node_template(self, class_type): if class_type not in NODE_CLASS_MAPPINGS: raise ValueError(f"Node class '{class_type}' not found. Ensure it's correctly imported in comfy_integration/nodes.py.") node_class = NODE_CLASS_MAPPINGS[class_type] input_types = node_class.INPUT_TYPES() all_inputs = {**input_types.get("required", {}), **input_types.get("optional", {})} return { "inputs": { name: (details[1].get("default") if len(details) > 1 and isinstance(details[1], dict) else None) for name, details in all_inputs.items() }, "class_type": class_type, "_meta": {"title": getattr(node_class, "NODE_NAME", class_type)}, } def _load_and_merge_recipe(self, recipe_filename, dynamic_values, search_context_dir=None): recipe_path_to_use = os.path.join(search_context_dir or self.base_path, recipe_filename) if not os.path.exists(recipe_path_to_use): raise FileNotFoundError(f"Recipe file not found: {recipe_path_to_use}") with open(recipe_path_to_use, "r", encoding="utf-8") as f: main_recipe = yaml.safe_load(_render_placeholders(f.read(), dynamic_values)) or {} merged_recipe = {"nodes": {}, "connections": [], "ui_map": {}} for key in self.injector_order: if key: merged_recipe[key] = {} parent_recipe_dir = os.path.dirname(recipe_path_to_use) for import_path_template in main_recipe.get("imports", []): import_path = _render_placeholders(import_path_template, dynamic_values) try: imported_recipe = self._load_and_merge_recipe(import_path, dynamic_values, search_context_dir=parent_recipe_dir) _merge_recipe_dict(merged_recipe, imported_recipe) except FileNotFoundError: print(f"Warning: Optional recipe partial '{import_path}' not found. Skipping.") return _merge_recipe_dict(merged_recipe, main_recipe) def add_node(self, class_type: str, inputs: dict = None, title: str = None, alias: str = None) -> str: node_data = deepcopy(self._get_node_template(class_type)) if title: node_data["_meta"]["title"] = title for k, v in (inputs or {}).items(): if k in node_data["inputs"]: node_data["inputs"][k] = v node_id = self._get_unique_id() self.workflow[node_id] = node_data if alias: self.node_map[alias] = node_id return node_id def connect(self, from_node: str, from_output_idx: int, to_node: str, to_input_name: str): from_id = self.node_map.get(from_node, from_node) to_id = self.node_map.get(to_node, to_node) if from_id in self.workflow and to_id in self.workflow: self.workflow[to_id]["inputs"][to_input_name] = [from_id, int(from_output_idx)] def assemble(self, ui_values): self.ui_values = ui_values self.node_counter = 0 self.workflow = {} self.node_map = {} for name, details in self.recipe.get("nodes", {}).items(): class_type = details.get("class_type") if not class_type: continue if match := _PLACEHOLDER_RE.search(class_type): class_type = ui_values.get(match.group(1)) if not class_type: continue self.add_node(class_type, inputs=details.get("params"), title=details.get("title"), alias=name) for target_name, target_param, val in _iter_ui_bindings(self.recipe.get("ui_map"), ui_values): if target_id := self.node_map.get(target_name): self.workflow[target_id]["inputs"][target_param] = val for conn in self.recipe.get("connections", []): if isinstance(conn.get("from"), str) and isinstance(conn.get("to"), str): from_name, from_output_idx = conn["from"].split(":", 1) to_name, to_input_name = conn["to"].split(":", 1) self.connect(from_name, int(from_output_idx), to_name, to_input_name) print("--- [Assembler] Applying dynamic injectors ---") processing_order = [key for key in self.injector_order if key in self.recipe] for chain_type in processing_order: injector_func = self.global_injectors.get(chain_type) if injector_func: for chain_key, chain_def in self.recipe.get(chain_type, {}).items(): if chain_key in ui_values and ui_values[chain_key]: print(f" -> Injecting '{chain_type}' for '{chain_key}'...") injector_func(self, chain_def, ui_values[chain_key]) print("--- [Assembler] Finished applying injectors ---") return self.workflow