MMnode/moxie_project.py
Z User 43d5bf9a1e feat: expose the latent upscaler as an upscale_model widget on Moxie MultiTrack Project Slow
The Slow node previously baked the upscaler checkpoint filename
(minimax_h3_latent_upscaler_3d_fp16.safetensors) into its settings with
no place on the node to choose it. The checkpoint is now a proper
upscale_model combo widget placed with the model components (after
audio_vae):

- options are None plus every file under ComfyUI/models/latent_upscale_models/
  (the bundled default is always kept selectable so the combo default is
  valid even before the checkpoint is downloaded)
- picking None (or an empty string, e.g. from a converted primitive
  socket) raises a clear error instead of silently falling back to the
  decode/RTX-resize/re-encode path this node exists to avoid
- workflows saved before the widget existed fall back to the bundled
  checkpoint, so they run unchanged
- engine untouched: the value flows through the existing
  kwargs.get('upscale_model') read; baked settings simply stop
  overriding it (base BAKED_PROJECT_SETTINGS copy pops the key)
- MoxieProject gains a _component_inputs() schema hook so subclasses can
  slot inputs in with the model components; base node schema unchanged
- tests: schema spot/ordering, folder listing without duplicates, widget
  passthrough, pre-widget fallback to the bundled checkpoint, None/empty
  rejection; CHANGELOG + multitrack-schema.md updated
2026-10-14 22:37:59 +00:00

323 lines
12 KiB
Python

from __future__ import annotations
import comfy.samplers
import folder_paths
from comfy_api.latest import io
from .nodes.project import (
EasyMultiTrackProject,
H3_CONTEXT_LENGTH_OPTIONS,
H3_CONTEXT_SOURCE_FRAMES,
TYPE_TRACKS_INFO,
_first_input,
)
# Values baked from the reference workflow (Moxie-clean.json). End users only
# control project_name, steps and seed on this node.
BAKED_PROJECT_SETTINGS = {
"project_save": "override",
"segment_start_number": 1,
"segment_count": -1,
"sampling_plan": "custom",
"sampling_mode": "single",
"1st_pass_only": False,
"disable_2nd_noise": False,
"upscale_by": 1.5,
"upscale_model": "None",
"enabled_tiling": "false",
}
BAKED_SAMPLER_NAME = "euler"
BAKED_SCHEDULER = "beta"
# Moxie MultiTrack Project Slow: the hidden half-resolution first pass is
# upscaled to the final size by the H3 latent upscaler model and refined with
# a short low-denoise euler pass instead of the RTX VSR pixel restore.
SLOW_UPSCALE_MODEL = "minimax_h3_latent_upscaler_3d_fp16.safetensors"
SLOW_SECOND_PASS_STEPS = 2
SLOW_SECOND_PASS_DENOISE = 0.33
SLOW_PROJECT_SETTINGS_DELTA = {
"sampling_mode": "dual",
# The first pass already runs at half the editor resolution, so the final
# size IS the editor size: a scale factor of 1.0 keeps the project
# manifest at the editor dimensions while the latent upscaler (target
# dimensions mode) bridges the half-res gap. The upscaler checkpoint is
# NOT baked: the Slow node exposes an upscale_model widget instead.
"upscale_by": 1.0,
}
def _require_moxie_components(model, clip, video_vae, audio_vae) -> None:
missing = [
name
for name, value in (
("model", model),
("clip", clip),
("video_vae", video_vae),
("audio_vae", audio_vae),
)
if value is None
]
if missing:
raise ValueError(
"MoxieProject: Missing required model components: "
+ ", ".join(missing)
+ ". Wire model, clip, video_vae, and audio_vae from Moxie Multimedia Loader."
)
def _denoise_truncated_sigmas(
model_sampling, scheduler: str, steps: int, denoise: float
):
"""Sigma schedule for `steps` steps at `denoise`, matching KSampler.
Replicates comfy KSampler.set_steps: build the schedule at
int(steps / denoise) total steps, then keep the last steps + 1 sigmas.
Written out because newer ComfyUI builds dropped the denoise kwarg from
comfy.samplers.calculate_sigmas.
"""
if denoise <= 0.0:
raise ValueError("denoise must be positive")
if denoise > 0.9999:
total_steps = steps
else:
total_steps = int(steps / denoise)
schedule = comfy.samplers.calculate_sigmas(
model_sampling, scheduler, total_steps
).cpu()
return schedule[-(steps + 1):]
class MoxieProject(EasyMultiTrackProject):
"""MultiTrack Project with the sampling stack consolidated.
Replaces: easy multitrackProject + 2x KSamplerSelect (euler / sa_solver)
+ BasicScheduler (beta) + ManualSigmas. Execution delegates to the
battle-tested Easy-Media implementation with sampler/sigmas computed
internally from the exposed `steps` widget.
"""
@classmethod
def _baked_project_settings(cls) -> dict:
return dict(BAKED_PROJECT_SETTINGS)
@classmethod
def _component_inputs(cls) -> list:
"""Extra inputs subclasses slot in after the model components."""
return []
@classmethod
def _project_inputs(cls) -> list:
inputs = [
TYPE_TRACKS_INFO.Input("tracks_info"),
io.Model.Input("model", tooltip="Diffusion model from Moxie Multimedia Loader (attention backend already applied)."),
io.Clip.Input("clip", tooltip="CLIP text encoder from Moxie Multimedia Loader."),
io.Vae.Input("video_vae", tooltip="Video VAE from Moxie Multimedia Loader."),
io.Vae.Input("audio_vae", tooltip="Audio VAE from Moxie Multimedia Loader (required to decode Moxie audio)."),
]
inputs.extend(cls._component_inputs())
inputs.extend(
[
io.String.Input("project_name", default="",
tooltip="Name of the project; used for output folders."),
io.Int.Input(
"steps",
default=3,
min=1,
max=10000,
tooltip="Sampling steps for the beta scheduler (3 for the baked-in 3-step distill; "
"8 for busy motion, 6 low motion, 4 runs/no dialogue).",
),
io.Combo.Input(
"context_frames",
options=[str(option) for option in H3_CONTEXT_LENGTH_OPTIONS],
default=str(H3_CONTEXT_SOURCE_FRAMES),
tooltip=(
"Video frames copied from the previous segment as "
"continuation context for segments whose continuity "
"mode is Context or Context Swap. Longer values hand "
"off motion more smoothly but generate that many extra "
"frames per segment. Values are H3 temporal-grid "
"lengths shared with the Moxie context sampler nodes."
),
),
io.Int.Input(
"seed",
default=42,
min=0,
max=0xFFFFFFFFFFFFFFFF,
step=1,
control_after_generate=io.ControlAfterGenerate.randomize,
),
]
)
return inputs
@classmethod
def define_schema(cls) -> io.Schema:
return io.Schema(
node_id="MoxieProject",
display_name="Moxie MultiTrack Project",
category="EasyUse/MultiTrackEditor",
description=(
"Build and execute a multi-track Moxie project. "
"Takes model, clip, video_vae and audio_vae directly from the Moxie Multimedia Loader. "
"Sampling is baked to a single pass with euler + beta sigmas; set only steps and seed."
),
is_input_list=True,
enable_expand=True,
not_idempotent=True,
inputs=cls._project_inputs(),
hidden=[io.Hidden.prompt, io.Hidden.unique_id],
outputs=[
io.String.Output("PROJECT_NAME"),
io.Audio.Output("LOCKED_AUDIO"),
],
)
@classmethod
def execute(cls, **kwargs) -> io.NodeOutput:
steps = int(_first_input(kwargs.get("steps"), 3))
model = _first_input(kwargs.get("model"))
clip = _first_input(kwargs.get("clip"))
video_vae = _first_input(kwargs.get("video_vae"))
audio_vae = _first_input(kwargs.get("audio_vae"))
_require_moxie_components(model, clip, video_vae, audio_vae)
# Pack the direct inputs into the loader dict consumed by
# EasyMultiTrackProject.execute (internal plumbing only).
synthesized_loader = {
"model": model,
"clip": clip,
"vae": video_vae,
"audio_vae": audio_vae,
}
# Same math as the native BasicScheduler node (scheduler=beta, denoise=1.0).
sigmas = comfy.samplers.calculate_sigmas(
model.get_model_object("model_sampling"), BAKED_SCHEDULER, steps
).cpu()
sigmas = sigmas[-(steps + 1):]
sampler = comfy.samplers.sampler_object(BAKED_SAMPLER_NAME)
baked = dict(kwargs)
baked.update(cls._baked_project_settings())
baked["model_loader"] = synthesized_loader
baked["sampler"] = sampler
baked["sigmas"] = sigmas
return super().execute(**baked)
class MoxieProjectSlow(MoxieProject):
"""Moxie MultiTrack Project with a latent-upscale refine pass.
Identical pipeline to MoxieProject (hidden half-resolution first pass,
euler + beta sampling from `steps`), except the low-resolution latent is
upscaled to the final size by a latent upscaler model chosen in the
`upscale_model` widget and refined with a 2-step euler pass at 0.33
denoise. Segments are saved at the project resolution, so the Video
Combine RTX restore passes through untouched - no NVIDIA RTX VSR is
used anywhere.
"""
@classmethod
def _latent_upscaler_options(cls) -> list:
models = list(folder_paths.get_filename_list("latent_upscale_models"))
if SLOW_UPSCALE_MODEL not in models:
# Keep the bundled checkpoint selectable even before it is
# downloaded; the combo default must always be a valid option.
models.append(SLOW_UPSCALE_MODEL)
return ["None"] + models
@classmethod
def _component_inputs(cls) -> list:
return [
io.Combo.Input(
"upscale_model",
options=cls._latent_upscaler_options(),
default=SLOW_UPSCALE_MODEL,
tooltip=(
"Latent upscaler checkpoint that brings the hidden "
"half-resolution first pass to the final size before "
"the 2-step refine. Files live under "
"ComfyUI/models/latent_upscale_models/; None is "
"rejected because this node always upscales in latent "
"space instead of the RTX restore."
),
)
]
@classmethod
def _baked_project_settings(cls) -> dict:
settings = dict(BAKED_PROJECT_SETTINGS)
# The upscaler checkpoint comes from the upscale_model widget.
settings.pop("upscale_model", None)
settings.update(SLOW_PROJECT_SETTINGS_DELTA)
return settings
@classmethod
def _h3_first_pass_resolution_scale(cls, sampling_mode: str) -> float:
# Dual mode would sample the first pass at the editor size; the Slow
# node keeps MoxieProject's hidden half-resolution speed trick and
# lets the latent upscaler bridge the gap instead of RTX VSR.
return 0.5
@classmethod
def define_schema(cls) -> io.Schema:
return io.Schema(
node_id="MoxieProjectSlow",
display_name="Moxie MultiTrack Project Slow",
category="EasyUse/MultiTrackEditor",
description=(
"Build and execute a multi-track Moxie project with a "
"latent-upscale refine pass. Takes model, clip, video_vae and "
"audio_vae directly from the Moxie Multimedia Loader and an "
"upscale_model checkpoint from latent_upscale_models. The "
"first pass samples euler + beta sigmas from steps, the "
"half-resolution latent is upscaled to the final size with "
"the chosen latent upscaler, and a 2-step euler pass at "
"0.33 denoise refines it; set only steps and seed."
),
is_input_list=True,
enable_expand=True,
not_idempotent=True,
inputs=cls._project_inputs(),
hidden=[io.Hidden.prompt, io.Hidden.unique_id],
outputs=[
io.String.Output("PROJECT_NAME"),
io.Audio.Output("LOCKED_AUDIO"),
],
)
@classmethod
def execute(cls, **kwargs) -> io.NodeOutput:
model = _first_input(kwargs.get("model"))
clip = _first_input(kwargs.get("clip"))
video_vae = _first_input(kwargs.get("video_vae"))
audio_vae = _first_input(kwargs.get("audio_vae"))
_require_moxie_components(model, clip, video_vae, audio_vae)
upscale_model = _first_input(kwargs.get("upscale_model"))
if upscale_model is None:
upscale_model = SLOW_UPSCALE_MODEL
upscale_model = str(upscale_model).strip()
if not upscale_model or upscale_model == "None":
raise ValueError(
"Moxie MultiTrack Project Slow always upscales the "
"half-resolution latent in latent space, so it needs a "
"model: pick a checkpoint in the upscale_model dropdown "
"(files under ComfyUI/models/latent_upscale_models/)."
)
sigmas_2nd = _denoise_truncated_sigmas(
model.get_model_object("model_sampling"),
BAKED_SCHEDULER,
SLOW_SECOND_PASS_STEPS,
SLOW_SECOND_PASS_DENOISE,
)
injected = dict(kwargs)
injected["sampler_2nd"] = comfy.samplers.sampler_object(BAKED_SAMPLER_NAME)
injected["sigmas_2nd"] = sigmas_2nd
injected["upscale_model"] = upscale_model
return super().execute(**injected)