File size: 6,971 Bytes
5b60657
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
"""Numeric sanity: tiny random-weight H3 latent upscaler through our wrappers / pieces."""
import sys
import types

import pytest
import torch
import torch.nn as nn
import torch.nn.functional as F

from h3s import h3s_upscale as up

pytestmark = pytest.mark.real_upscale_backends

# Pixaroma's LatentResizer3D (MIT, LBH port) — tiny channels for CPU speed.
# Load by file path so we don't shadow ComfyUI's top-level `nodes` package.
import importlib.util as _ilu
_HELPERS = "/tmp/comfyui-pixaroma/nodes/_h3_latent_upscale_helpers.py"
_spec = _ilu.spec_from_file_location("pixaroma_h3_latent_helpers", _HELPERS)
_mod = _ilu.module_from_spec(_spec)
_spec.loader.exec_module(_mod)
LatentResizer3D, LATENTS_MEAN, LATENTS_STD = _mod.LatentResizer3D, _mod.LATENTS_MEAN, _mod.LATENTS_STD


class _Out:
    def __init__(self, *args):
        self.result = args


def _tiny_pixaroma(channels=32, in_blocks=1, out_blocks=1):
    m = LatentResizer3D(in_channels=24, in_blocks=in_blocks, out_blocks=out_blocks,
                        channels=channels, dropout=0.0, temporal_every=0, temporal_kernel=3)
    m.eval().requires_grad_(False)
    return m


def _run_pix_model(model, video, width, height):
    """Mimic Pixaroma upscale_tensor normalisation + forward (CPU, fp32)."""
    B, C, T, H, W = video.shape
    h_out, w_out = height // 16, width // 16
    mean = torch.tensor(LATENTS_MEAN, dtype=torch.float32).view(1, -1, 1, 1, 1)
    std = torch.tensor(LATENTS_STD, dtype=torch.float32).view(1, -1, 1, 1, 1)
    scale = (width / (W * 16) + height / (H * 16)) / 2.0
    with torch.inference_mode():
        x = (video.float() - mean) / std
        y = model(x, scale=scale, target_size=(T, h_out, w_out), enable_chunking=False)
        y = y * std + mean
    return y.float().cpu()


def test_tiny_pixaroma_model_shapes_and_audio_untouched(monkeypatch):
    """Random-init Pixaroma network: video shape grows, temporal length kept; audio stays outside."""
    model = _tiny_pixaroma()
    video = torch.randn(1, 24, 7, 6, 8)   # 96×128 px, T=7
    audio = torch.randn(1, 32, 2, 40)

    class Pix:
        FUNCTION = "upscale"
        def upscale(self, latent, upscale_model, width, height):
            v = latent["samples"]
            assert v.shape[1] == 24
            out_v = _run_pix_model(model, v, width, height)
            return ({"samples": out_v},)

    monkeypatch.setattr(up, "_node_mappings", lambda: {"PixaromaH3LatentUpscale": Pix})
    z = up._pixaroma_once(video, 192, 160, "tiny.safetensors")
    assert z.shape == (1, 24, 7, 10, 12)
    assert z.dtype == torch.float32
    assert z.device.type == "cpu"
    # audio not passed through the video-only wrapper (run_upscale keeps it separately)
    assert audio.shape == (1, 32, 2, 40)


def test_native_wrapper_av_nested_passthrough(monkeypatch):
    """Native path: NestedTensor AV in → video upscaled, audio tensor identity preserved in output NestedTensor."""
    try:
        import comfy.nested_tensor as nt
    except Exception:
        pytest.skip("comfy.nested_tensor unavailable")

    class Loader:
        @classmethod
        def execute(cls, model_name):
            return _Out("MODEL")

    class Upscale:
        @classmethod
        def execute(cls, model, samples, width, height):
            assert model == "MODEL"
            lat = samples["samples"]
            if getattr(lat, "is_nested", False):
                video, audio = lat.tensors[0], lat.tensors[1]
                size = (video.shape[2], height // 16, width // 16)
                upscaled = F.interpolate(video.float(), size=size, mode="trilinear", align_corners=False)
                out = {"samples": nt.NestedTensor((upscaled, audio))}
            else:
                video = lat
                size = (video.shape[2], height // 16, width // 16)
                upscaled = F.interpolate(video.float(), size=size, mode="trilinear", align_corners=False)
                out = {"samples": upscaled}
            return _Out(out)

    monkeypatch.setattr(up, "_node_mappings", lambda: {
        "LatentUpscaleModelLoader": Loader,
        "MiniMaxH3LatentUpscaleWithModel": Upscale,
    })
    video = torch.randn(1, 24, 5, 4, 6)
    audio = torch.randn(1, 32, 2, 28)
    # Call through _native_once with plain video (production path); separately verify NestedTensor handling
    # via the Upscale class directly to assert audio identity
    samples = {"samples": nt.NestedTensor((video, audio))}
    res = Upscale.execute("MODEL", samples, 192, 128)
    out = res.result[0]["samples"]
    assert out.is_nested
    ov, oa = out.tensors[0], out.tensors[1]
    assert ov.shape == (1, 24, 5, 8, 12)
    assert torch.equal(oa, audio)

    # And our wrapper on plain video still returns the right shape on CPU float
    z = up._native_once(video, 192, 128, "m.safetensors")
    assert z.shape == (1, 24, 5, 8, 12) and z.device.type == "cpu"


def test_pieces_upscale_assembles_tiny_model(monkeypatch):
    """_pieces_upscale with a tiny Pixaroma model: 2 temporal pieces still assemble to full T and target HW."""
    model = _tiny_pixaroma()
    video = torch.randn(1, 24, 12, 4, 6)  # T=12 so temporal pieces split

    def once(x, ww, hh):
        return _run_pix_model(model, x, ww, hh)

    z = up._pieces_upscale(once, video, 192, 128, nt=2, ns=1)
    assert z.shape == (1, 24, 12, 8, 12)
    assert torch.isfinite(z).all()


def test_learned_upscale_chain_runs_tiny_pixaroma(monkeypatch):
    """Full learned_upscale → Pixaroma backend with tiny weights (native/LBH absent)."""
    model = _tiny_pixaroma()

    class Pix:
        FUNCTION = "upscale"
        def upscale(self, latent, upscale_model, width, height):
            return ({"samples": _run_pix_model(model, latent["samples"], width, height)},)

    monkeypatch.setattr(up, "learned_models", lambda: ["tiny.safetensors"])
    monkeypatch.setattr(up, "_node_mappings", lambda: {"PixaromaH3LatentUpscale": Pix})
    monkeypatch.setattr(up, "handoff", lambda *a, **k: None)
    v = torch.randn(1, 24, 7, 6, 8)
    z = up.learned_upscale(v, 192, 160)
    assert z is not None and z.shape == (1, 24, 7, 10, 12)


def test_upscale_input_end_to_end_with_tiny(monkeypatch):
    model = _tiny_pixaroma()

    class Pix:
        FUNCTION = "upscale"
        def upscale(self, latent, upscale_model, width, height):
            return ({"samples": _run_pix_model(model, latent["samples"], width, height)},)

    monkeypatch.setattr(up, "learned_models", lambda: ["tiny.safetensors"])
    monkeypatch.setattr(up, "_node_mappings", lambda: {"PixaromaH3LatentUpscale": Pix})
    monkeypatch.setattr(up, "handoff", lambda *a, **k: None)
    v = torch.randn(1, 24, 5, 4, 6)
    z, used = up.upscale_input(None, v, 192, 128, "learned")
    assert used == "learned" and z.shape == (1, 24, 5, 8, 12)