Files
ComfyUI-H3-Continuum-Tiled/tools/a2_audio_only_canary_node/__init__.py
T

231 lines
8.3 KiB
Python

"""Temporary GPU-canary node for the internal A2 Audio Only path."""
from __future__ import annotations
import hashlib
import importlib
import json
import sys
from types import SimpleNamespace
from typing import Any
import torch
def _single(name: str, value: Any) -> Any:
if not isinstance(value, list) or len(value) != 1:
raise ValueError(f"{name} must contain exactly one value")
return value[0]
def _active_modules() -> SimpleNamespace:
import nodes as comfy_nodes
sampler_class = comfy_nodes.NODE_CLASS_MAPPINGS.get("H3ContinuumSamplerV38")
if sampler_class is None:
raise RuntimeError("H3ContinuumSamplerV38 is not loaded")
module_name = sampler_class.__module__
base_name = (
module_name.split(".v3.", 1)[0]
if ".v3." in module_name
else module_name.rsplit(".", 2)[0]
)
return SimpleNamespace(
refine_schedule=importlib.import_module(f"{base_name}.v3.refine_schedule"),
refine_target=importlib.import_module(f"{base_name}.v3.refine_target"),
targeted_second_pass=importlib.import_module(
f"{base_name}.v3.targeted_second_pass"
),
)
def _samples(latent: Any, *, name: str) -> torch.Tensor:
if not isinstance(latent, dict) or not torch.is_tensor(latent.get("samples")):
raise ValueError(f"{name} must be a LATENT dictionary with Tensor samples")
return latent["samples"]
def _tensor_sha256(value: torch.Tensor) -> str:
tensor = value.detach().to(device="cpu").contiguous()
digest = hashlib.sha256()
digest.update(str(tuple(int(item) for item in tensor.shape)).encode("ascii"))
digest.update(str(tensor.dtype).encode("ascii"))
digest.update(tensor.view(torch.uint8).numpy().tobytes(order="C"))
return digest.hexdigest()
class H3A2AudioOnlyCanary:
"""Non-public bridge that records the A2 GPU acceptance contract."""
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"model": ("MODEL",),
"clip": ("CLIP",),
"sampler": ("SAMPLER",),
"sigmas": ("SIGMAS",),
"video_latents": ("LATENT",),
"audio_latents": ("LATENT",),
"assembly_plan": ("H3_CONTINUUM_ASSEMBLY_PLAN",),
"refine_seed": (
"INT",
{"default": 3802601, "min": 0, "max": 0xFFFFFFFFFFFFFFFF},
),
"schedule_mode": (["Tail", "External"], {"default": "Tail"}),
"tail_evaluations": (
"INT",
{"default": 6, "min": 1, "max": 100},
),
},
"optional": {
"refine_context": ("H3_CONTINUUM_REFINE_CONTEXT",),
"video_vae": ("VAE",),
},
}
INPUT_IS_LIST = True
RETURN_TYPES = ("LATENT", "LATENT", "H3_CONTINUUM_ASSEMBLY_PLAN", "STRING")
RETURN_NAMES = (
"video_latents",
"refined_audio_latents",
"updated_assembly_plan",
"canary_status",
)
OUTPUT_IS_LIST = (True, True, False, False)
FUNCTION = "run"
CATEGORY = "H3 Continuum Test/A2"
def run(
self,
model,
clip,
sampler,
sigmas,
video_latents,
audio_latents,
assembly_plan,
refine_seed,
schedule_mode,
tail_evaluations,
refine_context=None,
video_vae=None,
):
modules = _active_modules()
source_sigmas = _single("sigmas", sigmas)
mode = str(_single("schedule_mode", schedule_mode))
if mode == "Tail":
schedule = modules.refine_schedule.make_tail_schedule(
source_sigmas,
evaluation_count=int(
_single("tail_evaluations", tail_evaluations)
),
)
else:
schedule = None
input_video_samples = [
_samples(item, name=f"video_latents[{index}]")
for index, item in enumerate(video_latents)
]
input_audio_samples = [
_samples(item, name=f"audio_latents[{index}]")
for index, item in enumerate(audio_latents)
]
input_video_hashes = [_tensor_sha256(item) for item in input_video_samples]
input_audio_hashes = [_tensor_sha256(item) for item in input_audio_samples]
videos, audios, plan, status = (
modules.targeted_second_pass.run_targeted_second_pass_groups(
model=_single("model", model),
clip=_single("clip", clip),
sampler=_single("sampler", sampler),
sigmas=source_sigmas,
video_latents=video_latents,
audio_latents=audio_latents,
assembly_plan=_single("assembly_plan", assembly_plan),
refine_seed=int(_single("refine_seed", refine_seed)),
refine_target=modules.refine_target.MODE_AUDIO_ONLY,
refine_context=(
None
if refine_context is None
else _single("refine_context", refine_context)
),
video_vae=(
None if video_vae is None else _single("video_vae", video_vae)
),
refine_schedule=schedule,
enable_preview=False,
)
)
output_video_samples = [
_samples(item, name=f"output_video_latents[{index}]")
for index, item in enumerate(videos)
]
output_audio_samples = [
_samples(item, name=f"output_audio_latents[{index}]")
for index, item in enumerate(audios)
]
contract = plan["second_pass_contract"]
summary = {
"format": "h3-continuum-a2-audio-only-gpu-canary-v1",
"target": contract["refine_target_contract"],
"execution": contract["refine_execution_contract"],
"second_pass_contract_version": contract.get("version"),
"physical_groups": [
{
"group_id": group.get("group_id"),
"logical_chunks": group.get("logical_chunks"),
"terminal_merged": bool(group.get("terminal_merged")),
"source_latent_t": group.get("source_latent_t"),
"source_audio_shape": group.get("source_audio_shape"),
}
for group in contract.get("physical_groups", [])
],
"refine_group_seeds": contract.get("refine_group_seeds"),
"schedule_mode": contract["refine_schedule"]["mode"],
"schedule_evaluations": contract["refine_schedule"][
"evaluation_count"
],
"schedule_sigma_hash": contract["refine_schedule"]["sigma_hash"],
"video_object_identity": [
output is source
for output, source in zip(videos, video_latents, strict=True)
],
"video_tensor_identity": [
output is source
for output, source in zip(
output_video_samples,
input_video_samples,
strict=True,
)
],
"video_input_sha256": input_video_hashes,
"video_output_sha256": [
_tensor_sha256(item) for item in output_video_samples
],
"audio_input_sha256": input_audio_hashes,
"audio_output_sha256": [
_tensor_sha256(item) for item in output_audio_samples
],
"audio_input_shapes": [list(item.shape) for item in input_audio_samples],
"audio_output_shapes": [list(item.shape) for item in output_audio_samples],
"video_output_policy": contract.get("video_output"),
"video_sampling_policy": contract.get("video_sampling"),
"audio_output_policy": contract.get("audio_output"),
"audio_sampling_policy": contract.get("audio_sampling"),
}
canary_status = status + "\nA2_CANARY_JSON=" + json.dumps(
summary,
sort_keys=True,
separators=(",", ":"),
)
return videos, audios, plan, canary_status
NODE_CLASS_MAPPINGS = {"H3A2AudioOnlyCanary": H3A2AudioOnlyCanary}
NODE_DISPLAY_NAME_MAPPINGS = {
"H3A2AudioOnlyCanary": "H3 A2 Audio Only Canary (Temporary)"
}