Files
DumasNodes/dumas_vendored_nodes.py
T

157 lines
5.7 KiB
Python

"""Namespaced registrations for the complete vendored H3 upstream packs.
The source is kept under ``vendor/`` with its licenses and upstream layout
intact. This module is the only integration point: every upstream node gets a
DUMAS-prefixed ComfyUI id so the original packs can remain installed without
node-id collisions.
"""
from __future__ import annotations
import importlib
import logging
import copy
import dataclasses
import types
_PACKAGES = (
(".vendor.dumas_h3_continuum", "H3 Continuum", "DumasH3Continuum", "Dumas/MiniMax H3/Continuum"),
(".vendor.dumas_minimax_h3_refmod", "MiniMax H3 RefMod", "DumasMiniMaxH3RefMod", "Dumas/MiniMax H3/RefMod"),
(".vendor.dumas_h3_refmod_picker", "H3 RefMod Picker", "DumasH3RefModPicker", "Dumas/MiniMax H3/RefMod Picker"),
)
def _load_pack(package_name):
try:
return importlib.import_module(package_name)
except Exception:
logging.getLogger("DumasNodes").exception(
"Could not load vendored upstream pack %s", package_name,
)
return None
def _patch_schema(schema, *, node_id, category, display_name):
"""Return an upstream schema with DUMAS identity and category.
Comfy's modern schema objects have changed from mutable dataclasses to
immutable value objects across API revisions. Support both forms so the
vendored nodes remain usable on the same Comfy versions as their source
packs.
"""
changes = {"node_id": node_id, "category": category, "display_name": display_name}
if dataclasses.is_dataclass(schema):
try:
return dataclasses.replace(schema, **changes)
except (TypeError, ValueError):
pass
patched = copy.copy(schema)
for name, value in changes.items():
try:
setattr(patched, name, value)
except (AttributeError, TypeError):
try:
object.__setattr__(patched, name, value)
except (AttributeError, TypeError):
raise TypeError(
f"Cannot namespace Comfy schema {type(schema).__name__}.{name}"
) from None
return patched
def _namespace_class(node_class, *, node_id, category, display_name):
"""Wrap an upstream class without changing its execution implementation."""
define_schema = getattr(node_class, "define_schema", None)
if define_schema is None:
namespaced = types.new_class(node_class.__name__, (node_class,))
namespaced.CATEGORY = category
namespaced.NODE_CATEGORY = category
else:
def _define_schema(cls):
schema = node_class.define_schema()
return _patch_schema(
schema,
node_id=node_id,
category=category,
display_name=display_name,
)
namespaced = types.new_class(node_class.__name__, (node_class,))
namespaced.define_schema = classmethod(_define_schema)
# Older Comfy builds still inspect these class attributes while
# constructing the node search index.
namespaced.CATEGORY = category
namespaced.NODE_CATEGORY = category
if node_id == "DumasH3Continuum_H3ContinuumSamplerV39":
namespaced = _clean_v39_sampler_input(namespaced)
namespaced.__module__ = __name__
namespaced.__qualname__ = node_class.__qualname__
namespaced.__name__ = node_class.__name__
namespaced.__dumas_upstream_id__ = node_id
return namespaced
def _clean_v39_sampler_input(node_class):
"""Keep the DUMAS V3.9 manual-dimension surface without RefMods.
The sampler uses Continuum's native V3.9 ``reference_images`` bundle. We
retain the DUMAS cleanup that makes linked width/height authoritative and
removes duplicate legacy audio controls, without adding a second RefMod
conditioning path.
"""
original_input_types = node_class.INPUT_TYPES
@classmethod
def INPUT_TYPES(cls):
schema = original_input_types()
schema = {name: dict(value) for name, value in schema.items()}
required = dict(schema.get("required", {}))
for name in ("aspect", "preset", "custom_mp", "size_source"):
required.pop(name, None)
schema["required"] = required
optional = dict(schema.get("optional", {}))
for name in ("reference_audio_1", "reference_audio_vae"):
optional.pop(name, None)
schema["optional"] = optional
return schema
def run(self, **kwargs):
kwargs["size_source"] = "Manual"
kwargs.pop("aspect", None)
kwargs.pop("preset", None)
kwargs.pop("custom_mp", None)
return super(node_class, self).run(**kwargs)
node_class.run = run
node_class.INPUT_TYPES = INPUT_TYPES
return node_class
def _namespaced_mappings():
mappings = {}
display = {}
for relative_name, label, prefix, category in _PACKAGES:
package_name = (f"{__package__}{relative_name}" if __package__
else relative_name.lstrip("."))
pack = _load_pack(package_name)
if pack is None:
continue
source_mappings = getattr(pack, "NODE_CLASS_MAPPINGS", {}) or {}
source_display = getattr(pack, "NODE_DISPLAY_NAME_MAPPINGS", {}) or {}
for node_id, node_class in source_mappings.items():
dumas_id = f"{prefix}_{node_id}"
original_name = source_display.get(node_id, node_id)
dumas_name = f"DUMAS {label} · {original_name}"
mappings[dumas_id] = _namespace_class(
node_class,
node_id=dumas_id,
category=category,
display_name=dumas_name,
)
display[dumas_id] = dumas_name
return mappings, display
NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS = _namespaced_mappings()