ImageGen / core /workflow_assembler.py
RioShiina's picture
Refactor WorkflowAssembler for cleaner stateless assembly
3b8a7df verified
Raw History Blame Contribute Delete
8.89 kB
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