"""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()