[diffusion] refactor: deduplicate request extraction and ComfyUI test helpers (#42903)

Co-authored-by: Mick Qian <mickqian@users.noreply.github.com>
This commit is contained in:
Mick
2026-10-08 23:44:35 +08:00
committed by GitHub
co-authored by Mick Qian
parent 9f5d871251
commit 3030e31ff8
14 changed files with 233 additions and 223 deletions
@@ -0,0 +1,44 @@
"""Shared request setup and output checks for direct ComfyUI pipeline tests."""
import torch
def prepare_passthrough_request(req):
if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None:
req.do_classifier_free_guidance = True
else:
req.do_classifier_free_guidance = False
if req.seed is not None:
generator_device = req.generator_device
device_str = "cpu" if generator_device == "cpu" else "cuda"
req.generator = [
torch.Generator(device_str).manual_seed(req.seed + i)
for i in range(req.num_outputs_per_prompt)
]
else:
req.generator = [
torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt)
]
def check_passthrough_output(generator, req, *, label=""):
output_batch = generator._send_to_scheduler_and_wait_for_response([req])
noise_pred = output_batch.noise_pred
assert noise_pred is not None, "noise_pred should not be None in OutputBatch"
assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor"
assert noise_pred.device.type == "cuda", (
f"noise_pred should be on cuda, got {noise_pred.device}"
)
assert noise_pred.dtype == torch.bfloat16, (
f"noise_pred should be bfloat16, got {noise_pred.dtype}"
)
print(f"\u2713 Successfully retrieved noise_pred from OutputBatch{label}!")
print(f" noise_pred shape: {noise_pred.shape}")
print(f" noise_pred dtype: {noise_pred.dtype}")
print(f" noise_pred device: {noise_pred.device}")
latents = output_batch.output if output_batch.output is not None else req.latents
assert latents is not None, "latents should not be None"
return latents
@@ -6,6 +6,9 @@ import sys
import pytest
import torch
from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import (
check_passthrough_output,
)
from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams
from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator
from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request
@@ -140,25 +143,7 @@ def test_comfyui_flux_pipeline_direct() -> None:
torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt)
]
output_batch = generator._send_to_scheduler_and_wait_for_response([req])
noise_pred = output_batch.noise_pred
assert noise_pred is not None, "noise_pred should not be None in OutputBatch"
assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor"
assert noise_pred.device.type == "cuda", (
f"noise_pred should be on cuda, got {noise_pred.device}"
)
assert noise_pred.dtype == torch.bfloat16, (
f"noise_pred should be bfloat16, got {noise_pred.dtype}"
)
print("✓ Successfully retrieved noise_pred from OutputBatch!")
print(f" noise_pred shape: {noise_pred.shape}")
print(f" noise_pred dtype: {noise_pred.dtype}")
print(f" noise_pred device: {noise_pred.device}")
latents = output_batch.output if output_batch.output is not None else req.latents
assert latents is not None, "latents should not be None"
latents = check_passthrough_output(generator, req)
print(f"latents.shape: {latents.shape}")
@@ -6,6 +6,10 @@ import sys
import pytest
import torch
from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import (
check_passthrough_output,
prepare_passthrough_request,
)
from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams
from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator
from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request
@@ -94,42 +98,9 @@ def test_comfyui_qwen_image_edit_pipeline_direct() -> None:
req.vae_image_sizes = [(condition_width_latent, condition_height_latent)]
req.raw_latent_shape = torch.tensor(noisy_image_latents.shape, dtype=torch.long)
if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None:
req.do_classifier_free_guidance = True
else:
req.do_classifier_free_guidance = False
prepare_passthrough_request(req)
if req.seed is not None:
generator_device = req.generator_device
device_str = "cpu" if generator_device == "cpu" else "cuda"
req.generator = [
torch.Generator(device_str).manual_seed(req.seed + i)
for i in range(req.num_outputs_per_prompt)
]
else:
req.generator = [
torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt)
]
output_batch = generator._send_to_scheduler_and_wait_for_response([req])
noise_pred = output_batch.noise_pred
assert noise_pred is not None, "noise_pred should not be None in OutputBatch"
assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor"
assert noise_pred.device.type == "cuda", (
f"noise_pred should be on cuda, got {noise_pred.device}"
)
assert noise_pred.dtype == torch.bfloat16, (
f"noise_pred should be bfloat16, got {noise_pred.dtype}"
)
print("✓ Successfully retrieved noise_pred from OutputBatch (Edit Mode)!")
print(f" noise_pred shape: {noise_pred.shape}")
print(f" noise_pred dtype: {noise_pred.dtype}")
print(f" noise_pred device: {noise_pred.device}")
latents = output_batch.output if output_batch.output is not None else req.latents
assert latents is not None, "latents should not be None"
check_passthrough_output(generator, req, label=" (Edit Mode)")
if __name__ == "__main__":
@@ -6,6 +6,10 @@ import sys
import pytest
import torch
from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import (
check_passthrough_output,
prepare_passthrough_request,
)
from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams
from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator
from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request
@@ -78,42 +82,9 @@ def test_comfyui_qwen_image_pipeline_direct() -> None:
req.negative_prompt_embeds = [encoder_hidden_states]
req.raw_latent_shape = torch.tensor(hidden_states.shape, dtype=torch.long)
if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None:
req.do_classifier_free_guidance = True
else:
req.do_classifier_free_guidance = False
prepare_passthrough_request(req)
if req.seed is not None:
generator_device = req.generator_device
device_str = "cpu" if generator_device == "cpu" else "cuda"
req.generator = [
torch.Generator(device_str).manual_seed(req.seed + i)
for i in range(req.num_outputs_per_prompt)
]
else:
req.generator = [
torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt)
]
output_batch = generator._send_to_scheduler_and_wait_for_response([req])
noise_pred = output_batch.noise_pred
assert noise_pred is not None, "noise_pred should not be None in OutputBatch"
assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor"
assert noise_pred.device.type == "cuda", (
f"noise_pred should be on cuda, got {noise_pred.device}"
)
assert noise_pred.dtype == torch.bfloat16, (
f"noise_pred should be bfloat16, got {noise_pred.dtype}"
)
print("✓ Successfully retrieved noise_pred from OutputBatch!")
print(f" noise_pred shape: {noise_pred.shape}")
print(f" noise_pred dtype: {noise_pred.dtype}")
print(f" noise_pred device: {noise_pred.device}")
latents = output_batch.output if output_batch.output is not None else req.latents
assert latents is not None, "latents should not be None"
check_passthrough_output(generator, req)
if __name__ == "__main__":
@@ -6,6 +6,10 @@ import sys
import pytest
import torch
from sglang.multimodal_gen.apps.ComfyUI_SGLDiffusion.test.passthrough import (
check_passthrough_output,
prepare_passthrough_request,
)
from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams
from sglang.multimodal_gen.runtime.entrypoints.diffusion_generator import DiffGenerator
from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request
@@ -81,42 +85,9 @@ def test_comfyui_zimage_pipeline_direct() -> None:
req.negative_prompt_embeds = None
req.raw_latent_shape = torch.tensor(latents.shape, dtype=torch.long)
if req.guidance_scale > 1.0 and req.negative_prompt_embeds is not None:
req.do_classifier_free_guidance = True
else:
req.do_classifier_free_guidance = False
prepare_passthrough_request(req)
if req.seed is not None:
generator_device = req.generator_device
device_str = "cpu" if generator_device == "cpu" else "cuda"
req.generator = [
torch.Generator(device_str).manual_seed(req.seed + i)
for i in range(req.num_outputs_per_prompt)
]
else:
req.generator = [
torch.Generator("cuda") for _ in range(req.num_outputs_per_prompt)
]
output_batch = generator._send_to_scheduler_and_wait_for_response([req])
noise_pred = output_batch.noise_pred
assert noise_pred is not None, "noise_pred should not be None in OutputBatch"
assert isinstance(noise_pred, torch.Tensor), "noise_pred should be a torch.Tensor"
assert noise_pred.device.type == "cuda", (
f"noise_pred should be on cuda, got {noise_pred.device}"
)
assert noise_pred.dtype == torch.bfloat16, (
f"noise_pred should be bfloat16, got {noise_pred.dtype}"
)
print("✓ Successfully retrieved noise_pred from OutputBatch!")
print(f" noise_pred shape: {noise_pred.shape}")
print(f" noise_pred dtype: {noise_pred.dtype}")
print(f" noise_pred device: {noise_pred.device}")
latents = output_batch.output if output_batch.output is not None else req.latents
assert latents is not None, "latents should not be None"
check_passthrough_output(generator, req)
if __name__ == "__main__":
@@ -5,7 +5,7 @@ import base64
import contextlib
import os
import time
from typing import Any, List, Optional
from typing import List, Optional
from fastapi import (
APIRouter,
@@ -40,10 +40,11 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import (
add_common_data_to_response,
build_sampling_params,
choose_output_image_ext,
get_sampling_request_extra_fields,
merge_image_input_list,
process_generation_batch,
request_extra_value,
request_field_value,
request_model_kwargs,
resolve_sampling_params_cls,
sanitize_upload_filename,
save_image_to_path,
@@ -58,31 +59,6 @@ from sglang.srt.observability.trace import extract_trace_headers
router = APIRouter(prefix="/v1/images", tags=["images"])
def _get_extra_field(request, field_name):
return request_extra_value(request, field_name)
def _get_request_field_or_extra(request, field_name):
value = getattr(request, field_name, None)
if value is not None:
return value
return _get_extra_field(request, field_name)
def _image_request_model_kwargs(
request: ImageGenerationsRequest,
sampling_params_cls: type[SamplingParams],
) -> dict[str, Any]:
"""Extract fields owned and declared by the active model contract."""
kwargs = {}
for field_name in get_sampling_request_extra_fields(sampling_params_cls, "image"):
value = _get_extra_field(request, field_name)
if value is not None:
kwargs[field_name] = value
return kwargs
def _runtime_sampling_quality(quality: str | None) -> str | None:
"""Keep OpenAI's automatic default out of SGLang's sampling contract."""
return None if quality in (None, "auto") else quality
@@ -280,7 +256,7 @@ async def generations(
request_id = generate_request_id()
server_args = get_global_server_args()
sampling_params_cls = resolve_sampling_params_cls(server_args)
model_kwargs = _image_request_model_kwargs(request, sampling_params_cls)
model_kwargs = request_model_kwargs(request, sampling_params_cls, "image")
output_format = _resolve_image_output_format(
request.output_format, sampling_params_cls
)
@@ -308,24 +284,16 @@ async def generations(
guidance_scale=request.guidance_scale,
true_cfg_scale=request.true_cfg_scale,
negative_prompt=request.negative_prompt,
max_sequence_length=(
request.max_sequence_length
if request.max_sequence_length is not None
else _get_extra_field(request, "max_sequence_length")
),
flow_shift=(
request.flow_shift
if request.flow_shift is not None
else _get_extra_field(request, "flow_shift")
),
max_sequence_length=request_field_value(request, "max_sequence_length"),
flow_shift=request_field_value(request, "flow_shift"),
enable_teacache=request.enable_teacache,
enable_cache_dit=_get_extra_field(request, "enable_cache_dit"),
cache_dit_params=_get_extra_field(request, "cache_dit_params"),
cfg_gate_step=_get_extra_field(request, "cfg_gate_step"),
attention_backend_override=_get_extra_field(
enable_cache_dit=request_extra_value(request, "enable_cache_dit"),
cache_dit_params=request_extra_value(request, "cache_dit_params"),
cfg_gate_step=request_extra_value(request, "cfg_gate_step"),
attention_backend_override=request_extra_value(
request, "attention_backend_override"
),
skip_softmax_params=_get_extra_field(request, "skip_softmax_params"),
skip_softmax_params=request_extra_value(request, "skip_softmax_params"),
quality=_runtime_sampling_quality(request.quality),
output_compression=request.output_compression,
output_quality=request.output_quality,
@@ -334,11 +302,9 @@ async def generations(
upscaling_model_path=request.upscaling_model_path,
upscaling_scale=request.upscaling_scale,
perf_dump_path=request.perf_dump_path,
progressive_mode=_get_request_field_or_extra(request, "progressive_mode"),
progressive_levels=_get_request_field_or_extra(
request, "progressive_levels"
),
progressive_delta=_get_request_field_or_extra(request, "progressive_delta"),
progressive_mode=request_field_value(request, "progressive_mode"),
progressive_levels=request_field_value(request, "progressive_levels"),
progressive_delta=request_field_value(request, "progressive_delta"),
**model_kwargs,
)
trace_headers = extract_trace_headers(raw_request.headers)
@@ -14,6 +14,7 @@ from typing import Any, Generator, List, Literal, Optional, Union
import httpx
from fastapi import HTTPException, UploadFile
from pydantic import BaseModel
from sglang.multimodal_gen.configs.sample.sampling_params import (
DataType,
@@ -147,6 +148,14 @@ def request_extra_value(request: Any, field_name: str) -> Any:
return None
def request_field_value(request: BaseModel, field_name: str) -> Any:
"""Prefer a non-None protocol field over transport extras."""
value = vars(request).get(field_name)
if value is not None:
return value
return request_extra_value(request, field_name)
@cache
def get_declared_request_extra_fields(
sampling_params_cls: type[SamplingParams],
@@ -178,6 +187,20 @@ def get_sampling_request_extra_fields(
return declared & init_fields
def request_model_kwargs(
request: BaseModel,
sampling_params_cls: type[SamplingParams],
api: Literal["image", "video"],
) -> dict[str, Any]:
"""Extract only constructor fields declared by the active model contract."""
kwargs = {}
for field_name in get_sampling_request_extra_fields(sampling_params_cls, api):
value = request_extra_value(request, field_name)
if value is not None:
kwargs[field_name] = value
return kwargs
@contextmanager
def temp_dir_if_disabled(
configured_path: str | None,
@@ -44,10 +44,11 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import (
build_sampling_params,
flatten_extra_params,
get_declared_request_extra_fields,
get_sampling_request_extra_fields,
merge_image_input_list,
process_generation_batch,
request_extra_value,
request_field_value,
request_model_kwargs,
resolve_sampling_params_cls,
sanitize_upload_filename,
save_image_to_path,
@@ -97,31 +98,6 @@ async def shutdown_video_jobs() -> None:
await task
def _extra_value(request: VideoGenerationsRequest, name: str) -> Any:
return request_extra_value(request, name)
def _request_value(request: VideoGenerationsRequest, name: str) -> Any:
value = getattr(request, name, None)
if value is not None:
return value
return _extra_value(request, name)
def _video_request_model_kwargs(
request: VideoGenerationsRequest,
sampling_params_cls: type[SamplingParams],
) -> dict[str, Any]:
"""Extract fields owned and declared by the active model contract."""
kwargs = {}
for field_name in get_sampling_request_extra_fields(sampling_params_cls, "video"):
value = _extra_value(request, field_name)
if value is not None:
kwargs[field_name] = value
return kwargs
def _parse_form_extra_value(value: Any) -> Any:
if not isinstance(value, str):
return value
@@ -229,15 +205,17 @@ def _is_probably_video_source(source: Any) -> bool:
def _resolve_video_path(req: VideoGenerationsRequest) -> str | None:
video_path = _request_value(req, "video_path") or _request_value(req, "video_url")
video_path = request_field_value(req, "video_path") or request_field_value(
req, "video_url"
)
if video_path:
return str(video_path)
input_reference = _request_value(req, "input_reference")
input_reference = request_field_value(req, "input_reference")
if _is_probably_video_source(input_reference):
return str(input_reference)
reference_url = _request_value(req, "reference_url")
reference_url = request_field_value(req, "reference_url")
if _is_probably_video_source(reference_url):
return str(reference_url)
@@ -247,7 +225,7 @@ def _resolve_video_path(req: VideoGenerationsRequest) -> str | None:
def _resolve_image_path(
req: VideoGenerationsRequest, video_path: str | None
) -> str | None:
image_path = _request_value(req, "input_reference")
image_path = request_field_value(req, "input_reference")
if video_path and image_path == video_path:
return None
if _is_probably_video_source(image_path):
@@ -292,14 +270,14 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque
"max_sequence_length": request.max_sequence_length,
"flow_shift": request.flow_shift,
"enable_teacache": request.enable_teacache,
"use_diffusion_decoder": _extra_value(request, "use_diffusion_decoder"),
"enable_cache_dit": _extra_value(request, "enable_cache_dit"),
"cache_dit_params": _extra_value(request, "cache_dit_params"),
"cfg_gate_step": _extra_value(request, "cfg_gate_step"),
"attention_backend_override": _extra_value(
"use_diffusion_decoder": request_extra_value(request, "use_diffusion_decoder"),
"enable_cache_dit": request_extra_value(request, "enable_cache_dit"),
"cache_dit_params": request_extra_value(request, "cache_dit_params"),
"cfg_gate_step": request_extra_value(request, "cfg_gate_step"),
"attention_backend_override": request_extra_value(
request, "attention_backend_override"
),
"skip_softmax_params": _extra_value(request, "skip_softmax_params"),
"skip_softmax_params": request_extra_value(request, "skip_softmax_params"),
"enable_frame_interpolation": request.enable_frame_interpolation,
"frame_interpolation_exp": request.frame_interpolation_exp,
"frame_interpolation_scale": request.frame_interpolation_scale,
@@ -308,7 +286,7 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque
"upscaling_model_path": request.upscaling_model_path,
"upscaling_scale": request.upscaling_scale,
"output_path": request.output_path,
"quality": _extra_value(request, "quality"),
"quality": request_extra_value(request, "quality"),
"output_compression": request.output_compression,
"x264_preset": request.x264_preset,
"output_quality": request.output_quality,
@@ -317,7 +295,7 @@ def _build_video_sampling_params(request_id: str, request: VideoGenerationsReque
"num_profiled_timesteps": request.num_profiled_timesteps,
"profile_all_stages": request.profile_all_stages,
"diffusers_kwargs": request.diffusers_kwargs,
**_video_request_model_kwargs(request, sampling_params_cls),
**request_model_kwargs(request, sampling_params_cls, "video"),
}
kwargs = sampling_params_cls.lower_video_request_kwargs(request, kwargs)
@@ -680,6 +680,8 @@ class LTX2VideoDiffusionDecoder3d(nn.Module):
self.trailing_pad_latent_frames = (stage_kernels[0][0] // 2) * 2
self.conv_in = nn.Linear(arch.latent_channels, stage_channels[0], bias=True)
# checkpoint keyframe-stream tag; ordinary video decoding does not use it
self.type_emb = nn.Parameter(torch.zeros(arch.latent_channels))
self.det_stages = nn.ModuleList()
self.upsamples = nn.ModuleList()
@@ -730,6 +732,31 @@ class LTX2VideoDiffusionDecoder3d(nn.Module):
self.norm_out = nn.RMSNorm(stage5_channels, eps=1e-6)
self.conv_out = nn.Linear(stage5_channels, noised_pixel_channels, bias=True)
def _load_from_state_dict(
self,
state_dict,
prefix,
local_metadata,
strict,
missing_keys,
unexpected_keys,
error_msgs,
):
# older checkpoints predate the keyframe tag and use a zero embedding
state_dict.setdefault(
prefix + "type_emb",
torch.zeros(self.type_emb.shape, dtype=self.type_emb.dtype, device="cpu"),
)
super()._load_from_state_dict(
state_dict,
prefix,
local_metadata,
strict,
missing_keys,
unexpected_keys,
error_msgs,
)
def forward_stages_1_to_3(self, hidden_states: torch.Tensor) -> torch.Tensor:
"""Latent `(B, C, T, H, W)` to a channels-last feature volume."""
num_pad = self.trailing_pad_latent_frames
@@ -41,10 +41,10 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import (
ImageGenerationsRequest,
VideoGenerationsRequest,
)
from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs
from sglang.multimodal_gen.runtime.entrypoints.openai.video_api import (
_multipart_video_extras,
_resolve_video_path,
_video_request_model_kwargs,
)
from sglang.multimodal_gen.runtime.loader.component_loaders import scheduler_loader
from sglang.multimodal_gen.runtime.loader.component_loaders.scheduler_loader import (
@@ -1059,7 +1059,7 @@ class TestCosmos3OpenAIProtocol(unittest.TestCase):
self.assertEqual(_resolve_video_path(req), "https://example.com/input.mp4")
kwargs = _video_request_model_kwargs(req, Cosmos3SamplingParams)
kwargs = request_model_kwargs(req, Cosmos3SamplingParams, "video")
kwargs.update(num_frames=48, fps=24)
kwargs = Cosmos3SamplingParams.lower_video_request_kwargs(req, kwargs)
self.assertEqual(kwargs["sound_duration"], 2.0)
@@ -1117,7 +1117,7 @@ class TestCosmos3OpenAIProtocol(unittest.TestCase):
req = VideoGenerationsRequest(
prompt="test", generate_sound=False, sound_duration=3.0
)
kwargs = _video_request_model_kwargs(req, Cosmos3SamplingParams)
kwargs = request_model_kwargs(req, Cosmos3SamplingParams, "video")
kwargs.update(num_frames=48, fps=24)
kwargs = Cosmos3SamplingParams.lower_video_request_kwargs(req, kwargs)
self.assertEqual(kwargs["sound_duration"], 0.0)
@@ -19,7 +19,6 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.image_api import (
_build_image_response_kwargs,
_fallback_image_urls,
_get_response_resize,
_image_request_model_kwargs,
_raise_if_image_variant_not_found,
_runtime_sampling_quality,
_select_image_variant_cloud_url,
@@ -29,6 +28,7 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.image_api import (
from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import (
ImageGenerationsRequest,
)
from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs
from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import OutputBatch
@@ -84,10 +84,10 @@ def test_longcat_image_fields_remain_model_specific():
assert field_name in longcat_fields
assert getattr(request, field_name) == value
assert _image_request_model_kwargs(request, LongCatImageSamplingParams) == (
assert request_model_kwargs(request, LongCatImageSamplingParams, "image") == (
field_values
)
assert _image_request_model_kwargs(request, SamplingParams) == {}
assert request_model_kwargs(request, SamplingParams, "image") == {}
def test_longcat_image_fields_accept_nested_extra_body():
@@ -101,7 +101,7 @@ def test_longcat_image_fields_accept_nested_extra_body():
},
)
assert _image_request_model_kwargs(request, LongCatImageSamplingParams) == {
assert request_model_kwargs(request, LongCatImageSamplingParams, "image") == {
"enable_prompt_rewrite": True,
"enable_cfg_renorm": False,
"cfg_renorm_min": 0.5,
@@ -127,10 +127,10 @@ def test_other_image_extensions_remain_model_specific():
assert field_name not in ImageGenerationsRequest.model_fields
assert field_name not in base_fields
assert field_name in model_fields
assert _image_request_model_kwargs(request, sampling_params_cls) == {
assert request_model_kwargs(request, sampling_params_cls, "image") == {
field_name: value
}
assert _image_request_model_kwargs(request, SamplingParams) == {}
assert request_model_kwargs(request, SamplingParams, "image") == {}
def test_cosmos_image_guardrails_alias_is_preserved():
@@ -139,7 +139,7 @@ def test_cosmos_image_guardrails_alias_is_preserved():
extra_body={"guardrails": False},
)
assert _image_request_model_kwargs(request, Cosmos3SamplingParams) == {
assert request_model_kwargs(request, Cosmos3SamplingParams, "image") == {
"use_guardrails": False
}
@@ -2,20 +2,57 @@
import asyncio
import io
import json
from types import SimpleNamespace
from starlette.datastructures import UploadFile as StarletteUploadFile
from sglang.multimodal_gen.configs.sample.minimax_h3 import MiniMaxH3SamplingParams
from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams
from sglang.multimodal_gen.runtime.entrypoints.openai import utils as openai_utils
from sglang.multimodal_gen.runtime.entrypoints.openai.protocol import (
ImageGenerationsRequest,
VideoGenerationsRequest,
)
from sglang.multimodal_gen.runtime.entrypoints.openai.utils import (
_parse_size_or_raise,
_save_upload_to_path,
_validate_positive_int,
build_sampling_params,
request_field_value,
request_model_kwargs,
)
def test_request_fields_preserve_falsy_values_and_extra_precedence():
for cls in (ImageGenerationsRequest, VideoGenerationsRequest):
for container in ("extra_body", "extra_json", "extra_args", "extra_params"):
for direct in (0, None):
request = cls(
prompt="test",
seed=direct,
enable_cache_dit=False,
**{container: json.dumps({"seed": 42, "enable_cache_dit": True})},
)
before = request.model_dump()
assert request_field_value(request, "seed") == (
42 if direct is None else 0
)
assert request_field_value(request, "enable_cache_dit") is False
assert request.model_dump() == before
def test_video_model_kwargs_exclude_transport_only_aliases():
request = VideoGenerationsRequest(
prompt="test", extra_body={"task": "t2va", "audio_guidance_scale": 2.0}
)
assert request_model_kwargs(request, MiniMaxH3SamplingParams, "video") == {
"task": "t2va"
}
assert request.model_extra["extra_body"]["audio_guidance_scale"] == 2.0
assert request_model_kwargs(request, MiniMaxH3SamplingParams, "image") == {}
def test_save_upload_to_path_accepts_starlette_upload_file(tmp_path):
upload = StarletteUploadFile(
io.BytesIO(b"image-bytes"),
@@ -193,6 +193,43 @@ def test_real_components_restore_weights_and_exact_policy(
torch.testing.assert_close(model(inputs), reference(inputs), rtol=0, atol=0)
@pytest.mark.parametrize("has_type_embedding", [False, True])
def test_diffusion_decoder_restores_optional_keyframe_tag(tmp_path, has_type_embedding):
role, class_name, config_cls, raw_config = CASES[3]
config = config_cls()
config.update_model_arch(raw_config)
model_cls, _ = ModelRegistry.resolve_model_cls(class_name)
reference = model_cls(config)
with torch.no_grad():
for parameter in reference.parameters():
parameter.fill_(0.25)
weights = reference.state_dict()
if not has_type_embedding:
weights.pop("decoder.type_emb")
component = tmp_path / role
_write_checkpoint(component, {"_class_name": class_name, **raw_config}, weights)
args = ServerArgs(
model_path="x",
component_precisions={role: "fp32"},
component_residency={role: "component-offload"},
)
model, _ = PipelineComponentLoader.load_component(
role, str(component), "diffusers", args
)
expected = torch.full(
(raw_config["latent_channels"],), 0.25 if has_type_embedding else 0.0
)
torch.testing.assert_close(model.decoder.type_emb.cpu(), expected, rtol=0, atol=0)
for key, tensor in weights.items():
torch.testing.assert_close(
model.state_dict()[key].cpu(), tensor, rtol=0, atol=0
)
with pytest.raises(RuntimeError, match="size mismatch for decoder.type_emb"):
model.load_state_dict({**weights, "decoder.type_emb": torch.zeros(5)})
with pytest.raises(RuntimeError, match="Unexpected key"):
model.load_state_dict({**weights, "decoder.unknown": torch.zeros(1)})
class _DecoderOnly(nn.Module):
def __init__(self, config):
super().__init__()
@@ -14,9 +14,9 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.realtime.realtime_adapter
RealtimeChunkInputs,
build_realtime_sampling_params,
)
from sglang.multimodal_gen.runtime.entrypoints.openai.utils import request_model_kwargs
from sglang.multimodal_gen.runtime.entrypoints.openai.video_api import (
_build_video_sampling_params,
_video_request_model_kwargs,
create_video,
)
from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import Req
@@ -88,8 +88,8 @@ def test_ltx25_video_extensions_remain_model_specific():
assert field_name not in base_fields
assert field_name in ltx25_fields
assert _video_request_model_kwargs(request, LTX25SamplingParams) == field_values
assert _video_request_model_kwargs(request, SamplingParams) == {}
assert request_model_kwargs(request, LTX25SamplingParams, "video") == field_values
assert request_model_kwargs(request, SamplingParams, "video") == {}
def test_ltx23_request_defaults_to_vae_decoder():