diff --git a/docs/docs/sglang-diffusion/api/openai_api.mdx b/docs/docs/sglang-diffusion/api/openai_api.mdx index 45d1bfc7f9..4c118a5337 100644 --- a/docs/docs/sglang-diffusion/api/openai_api.mdx +++ b/docs/docs/sglang-diffusion/api/openai_api.mdx @@ -579,5 +579,5 @@ The server supports adjusting output quality and compression levels for both ima #### Notes - **Precedence**: When both `output-quality` and `output-compression` are provided, `output-compression` takes precedence -- **Format Support**: Quality settings apply to JPEG, and video formats. PNG uses lossless compression and ignores these settings +- **Format Support**: Quality settings apply to JPEG, and video formats. PNG is lossless: by default it is stored without zlib compression, which encodes fastest but keeps files close to the raw pixel size; an `output-compression` other than 75 selects zlib level `round(output-compression / 100 * 9)` instead - **File Size vs Quality**: Lower compression values (or "low" quality preset) produce smaller files but may show visible artifacts diff --git a/docs/docs/sglang-diffusion/performance-optimization.mdx b/docs/docs/sglang-diffusion/performance-optimization.mdx index 962239751d..d8564fdd13 100644 --- a/docs/docs/sglang-diffusion/performance-optimization.mdx +++ b/docs/docs/sglang-diffusion/performance-optimization.mdx @@ -172,10 +172,11 @@ saving. ### Scope and tradeoffs -- Only the output rank performs asynchronous saving, and only for requests that - save files and return their paths (`save_output=true` and - `return_file_paths_only=true` in the sampling parameters). -- Warmup requests, raw-frame responses, requests with `save_output=false`, and +- Only the output rank performs asynchronous saving, and only for requests whose + outputs it encodes: `return_file_paths_only=true` together with + `save_output=true` or `return_image_bytes=true` (set by `/v1/images`) in the + sampling parameters. +- Warmup requests, raw-frame responses, other requests with `save_output=false`, and requests with `perf_dump_path` set or `SGLANG_DIFFUSION_STAGE_LOGGING=1` keep the synchronous path. This includes the frame-return path used by `/rollout/generate`. - Each reply is sent from the saving thread as soon as its output is saved, diff --git a/python/sglang/multimodal_gen/configs/sample/sampling_params.py b/python/sglang/multimodal_gen/configs/sample/sampling_params.py index d86badf826..8900c67e13 100644 --- a/python/sglang/multimodal_gen/configs/sample/sampling_params.py +++ b/python/sglang/multimodal_gen/configs/sample/sampling_params.py @@ -461,6 +461,8 @@ class SamplingParams: # return output file paths directly to client return_file_paths_only: bool = True + # also return each image's encoded bytes, which are written to disk only when save_output + return_image_bytes: bool = False enable_sequence_shard: bool | None = None diffusers_kwargs: dict | None = None max_sequence_length: int | None = None diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py index 821c13f6b3..b842c17690 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py @@ -3,6 +3,7 @@ import asyncio import base64 import contextlib +import io import os import time from typing import List, Optional @@ -73,13 +74,8 @@ def _resolve_image_output_format( return sampling_params_cls.default_image_output_format() -def _read_b64_for_paths(paths: list[str]) -> list[str]: - """Read and base64-encode each file. Must be called before cloud upload deletes them.""" - result = [] - for path in paths: - with open(path, "rb") as f: - result.append(base64.b64encode(f.read()).decode("utf-8")) - return result +def _b64_encode_images(images: list[bytes]) -> list[str]: + return [base64.b64encode(image).decode("utf-8") for image in images] async def _upload_and_cleanup_images(paths: list[str]) -> list[str | None]: @@ -181,7 +177,7 @@ def _build_image_response_kwargs( ) -> dict: """Build ImageResponse data list. - For b64_json: uses pre-read b64_list (call _read_b64_for_paths first). + For b64_json: uses b64_list, the base64 of the returned image bytes. For url: uses cloud_url or fallback_url. file_path is omitted when is_persistent=False to avoid exposing stale temp paths. """ @@ -246,15 +242,15 @@ def _build_image_response_kwargs( def _get_response_resize( - sampling_params: SamplingParams, output_path: str | None = None + sampling_params: SamplingParams, output_image_bytes: bytes | None = None ) -> str | None: """Return a generated GLM-Image output's actual size as WIDTHxHEIGHT.""" if not isinstance(sampling_params, GlmImageSamplingParams): return None - if output_path is not None: + if output_image_bytes is not None: try: - with Image.open(output_path) as output_image: + with Image.open(io.BytesIO(output_image_bytes)) as output_image: width, height = output_image.size return f"{width}x{height}" except (OSError, ValueError): @@ -303,6 +299,10 @@ async def generations( raw_request, request.prompt, enabled=request.enhance_prompt, task="image" ) + # responses carry the encoded bytes; files are written only to persist or upload them + write_output_files = ( + server_args.output_path is not None or cloud_storage.is_enabled() + ) with temp_dir_if_disabled(server_args.output_path) as output_dir: sampling = _build_request_sampling_params( request_id, @@ -315,6 +315,8 @@ async def generations( num_outputs_per_prompt=max(1, min(int(request.n or 1), 10)), output_file_name=f"{request_id}.{ext}", output_path=output_dir, + save_output=write_output_files, + return_image_bytes=True, num_frames=1, seed=request.seed, generator_device=request.generator_device, @@ -362,11 +364,10 @@ async def generations( async_scheduler_client, batch ) save_file_path = save_file_path_list[0] - response_resize = _get_response_resize(sampling, save_file_path) + response_resize = _get_response_resize(sampling, result.output_image_bytes[0]) - # read b64 before cloud upload may delete the local file b64_list = ( - _read_b64_for_paths(save_file_path_list) + _b64_encode_images(result.output_image_bytes) if resp_format == "b64_json" else None ) @@ -496,6 +497,10 @@ async def edits( ) ext = choose_output_image_ext(output_format, background) + # responses carry the encoded bytes; files are written only to persist or upload them + write_output_files = ( + server_args.output_path is not None or cloud_storage.is_enabled() + ) prompt = await maybe_enhance_prompt( raw_request, prompt, @@ -512,6 +517,8 @@ async def edits( num_outputs_per_prompt=max(1, min(int(n or 1), 10)), output_file_name=f"{request_id}.{ext}", output_path=output_dir, + save_output=write_output_files, + return_image_bytes=True, image_path=input_paths, seed=seed, generator_device=generator_device, @@ -544,11 +551,10 @@ async def edits( async_scheduler_client, batch ) save_file_path = save_file_path_list[0] - response_resize = _get_response_resize(sampling, save_file_path) + response_resize = _get_response_resize(sampling, result.output_image_bytes[0]) - # read b64 before cloud upload may delete the local file b64_list = ( - _read_b64_for_paths(save_file_path_list) + _b64_encode_images(result.output_image_bytes) if resp_format == "b64_json" else None ) diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py index 10d7e845eb..aa3c6824f4 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py @@ -590,6 +590,7 @@ async def process_generation_batch( save_file_path_list = result.output_file_paths elif result.output is not None: num_outputs = len(result.output) + image_bytes = [] if batch.return_image_bytes else None save_file_path_list = save_outputs( result.output, batch.data_type, @@ -598,6 +599,7 @@ async def process_generation_batch( lambda idx: str(batch.output_file_path(num_outputs, idx)), audio=result.audio, audio_sample_rate=result.audio_sample_rate, + image_bytes_out=image_bytes, output_compression=batch.output_compression, x264_preset=batch.x264_preset, enable_frame_interpolation=batch.enable_frame_interpolation, @@ -608,6 +610,7 @@ async def process_generation_batch( upscaling_model_path=batch.upscaling_model_path, upscaling_scale=batch.upscaling_scale, ) + result.output_image_bytes = image_bytes total_time = time.perf_counter() - total_start_time if get_global_server_args().batching_max_size > 1: diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/utils.py b/python/sglang/multimodal_gen/runtime/entrypoints/utils.py index 372567b831..2458c62963 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/utils.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/utils.py @@ -9,6 +9,7 @@ diffusion models. """ import atexit +import io import json import mmap import os @@ -1192,15 +1193,30 @@ def save_materialized_output( save_file_path: Optional[str], *, save_output: bool = True, + return_image_bytes: bool = False, audio_sample_rate: Optional[int] = None, output_compression: Optional[int] = None, x264_preset: Optional[str] = None, -) -> None: +) -> bytes | None: + """save the output when save_output; return a single-frame image's encoded bytes + + return_image_bytes encodes the image even when it is not saved; a saved file holds + the same bytes + """ + image_bytes = None + if ( + return_image_bytes + and data_type != DataType.VIDEO + and len(materialized.frames) == 1 + ): + image_bytes = _encode_image_frame( + materialized.frames[0], save_file_path, output_compression + ) if not save_output: - return + return image_bytes if not save_file_path: logger.info("No output path provided, output not saved") - return + return image_bytes os.makedirs(os.path.dirname(save_file_path), exist_ok=True) if data_type == DataType.VIDEO: @@ -1230,53 +1246,57 @@ def save_materialized_output( fps=materialized.fps, audio_sample_rate=audio_sample_rate, ) + elif len(materialized.frames) > 1: + for i, image in enumerate(materialized.frames): + parts = save_file_path.rsplit(".", 1) + if len(parts) == 2: + indexed_path = f"{parts[0]}_{i}.{parts[1]}" + else: + indexed_path = f"{save_file_path}_{i}" + with open(indexed_path, "wb") as f: + f.write(_encode_image_frame(image, indexed_path, output_compression)) else: - quality = output_compression if output_compression is not None else 75 - if len(materialized.frames) > 1: - for i, image in enumerate(materialized.frames): - parts = save_file_path.rsplit(".", 1) - if len(parts) == 2: - indexed_path = f"{parts[0]}_{i}.{parts[1]}" - else: - indexed_path = f"{save_file_path}_{i}" - _save_image_frame(indexed_path, image, quality, output_compression) - else: - _save_image_frame( - save_file_path, materialized.frames[0], quality, output_compression + if image_bytes is None: + image_bytes = _encode_image_frame( + materialized.frames[0], save_file_path, output_compression ) + with open(save_file_path, "wb") as f: + f.write(image_bytes) logger.info(f"Output saved to {CYAN}{save_file_path}{RESET}") + return image_bytes -def _save_image_frame( - path: str, frame: np.ndarray, quality: int | None, output_compression: int | None -) -> None: +def _encode_image_frame( + frame: np.ndarray, path: str, output_compression: int | None +) -> bytes: + """encode a frame in the image format named by path's extension""" ext = os.path.splitext(path)[1].lower() if ext == ".png": - compress_level = 1 + # zlib level 0 skips compression: several times faster, ~3x the bytes, same pixels + compress_level = 0 if output_compression is not None and output_compression != 75: compress_level = max(0, min(9, round(output_compression / 100 * 9))) if frame.ndim == 3 and frame.shape[-1] == 1: frame = frame[..., 0] - Image.fromarray(frame).save(path, format="PNG", compress_level=compress_level) - else: - if ext in (".jpg", ".jpeg") and frame.ndim == 3 and frame.shape[-1] == 4: - # Models such as Qwen-Image 2.1 produce RGBA even for opaque scenes. - # JPEG needs RGB; composite on white instead of dropping alpha and - # exposing arbitrary colors from transparent pixels. - rgba = Image.fromarray(frame) - background = Image.new("RGB", rgba.size, (255, 255, 255)) - background.paste(rgba, mask=rgba.getchannel("A")) - frame = np.asarray(background) - imageio.imwrite(path, frame, quality=quality) + buffer = io.BytesIO() + Image.fromarray(frame).save(buffer, format="PNG", compress_level=compress_level) + return buffer.getvalue() + if ext in (".jpg", ".jpeg") and frame.ndim == 3 and frame.shape[-1] == 4: + # Models such as Qwen-Image 2.1 produce RGBA even for opaque scenes. + # JPEG needs RGB; composite on white instead of dropping alpha and + # exposing arbitrary colors from transparent pixels. + rgba = Image.fromarray(frame) + background = Image.new("RGB", rgba.size, (255, 255, 255)) + background.paste(rgba, mask=rgba.getchannel("A")) + frame = np.asarray(background) + quality = output_compression if output_compression is not None else 75 + return imageio.imwrite("", frame, format=ext, quality=quality) def warm_image_writer() -> None: """Run imageio's one-time plugin setup (~30 ms) before the first request saves.""" try: - with tempfile.TemporaryDirectory() as tmp: - _save_image_frame( - os.path.join(tmp, "warm.jpg"), np.zeros((8, 8, 3), np.uint8), 75, None - ) + _encode_image_frame(np.zeros((8, 8, 3), np.uint8), "warm.jpg", None) except Exception: logger.debug("Image writer warmup failed", exc_info=True) @@ -1293,6 +1313,7 @@ def save_outputs( samples_out: Optional[list[Any]] = None, audios_out: Optional[list[Any]] = None, frames_out: Optional[list[Any]] = None, + image_bytes_out: Optional[list[bytes | None]] = None, output_compression: Optional[int] = None, x264_preset: Optional[str] = None, enable_frame_interpolation: bool = False, @@ -1386,6 +1407,7 @@ def save_outputs( audio_sample_rate=audio_sample_rate, output_compression=output_compression, x264_preset=x264_preset, + image_bytes_out=image_bytes_out, enable_frame_interpolation=enable_frame_interpolation, frame_interpolation_exp=frame_interpolation_exp, frame_interpolation_scale=frame_interpolation_scale, @@ -1424,8 +1446,9 @@ def post_process_sample( upscaling_model_path: Optional[str] = None, upscaling_scale: int = 4, x264_preset: Optional[str] = None, + image_bytes_out: Optional[list[bytes | None]] = None, ) -> list[Any]: - """materialize frames and save outputs (optional)""" + """materialize frames and save outputs (optional); image_bytes_out collects the encoded image""" if data_type == DataType.ACTION: return [] @@ -1441,13 +1464,16 @@ def post_process_sample( upscaling_model_path=upscaling_model_path, upscaling_scale=upscaling_scale, ) - save_materialized_output( + image_bytes = save_materialized_output( materialized, data_type, save_file_path, save_output=save_output, + return_image_bytes=image_bytes_out is not None, audio_sample_rate=audio_sample_rate, output_compression=output_compression, x264_preset=x264_preset, ) + if image_bytes_out is not None: + image_bytes_out.append(image_bytes) return materialized.frames diff --git a/python/sglang/multimodal_gen/runtime/managers/gpu_worker.py b/python/sglang/multimodal_gen/runtime/managers/gpu_worker.py index fcb31631c8..e86bcc384a 100644 --- a/python/sglang/multimodal_gen/runtime/managers/gpu_worker.py +++ b/python/sglang/multimodal_gen/runtime/managers/gpu_worker.py @@ -889,7 +889,7 @@ class GPUWorker(GPUWorkerPostTrainingMixin): self._async_output_save and not req.is_warmup and not req.return_raw_frames - and bool(req.save_output and req.return_file_paths_only) + and self._encodes_on_output_rank(req) and req.perf_dump_path is None and not envs.SGLANG_DIFFUSION_STAGE_LOGGING ) @@ -981,11 +981,18 @@ class GPUWorker(GPUWorkerPostTrainingMixin): ) -> None: if req.return_raw_frames: self._materialize_raw_frame_transport(output_batch, req) - elif req.save_output and req.return_file_paths_only: + elif self._encodes_on_output_rank(req): self._materialize_file_path_transport(output_batch, save_output_paths) elif getattr(req, "return_frames", False): self._materialize_frame_outputs_for_return(output_batch, req) + @staticmethod + def _encodes_on_output_rank(req: Req) -> bool: + # the output rank encodes the outputs to save them or to return the image bytes + return req.return_file_paths_only and ( + req.save_output or req.return_image_bytes + ) + def _materialize_raw_frame_transport( self, output_batch: OutputBatch, req: Req ) -> None: @@ -1291,14 +1298,16 @@ class GPUWorker(GPUWorkerPostTrainingMixin): def build_output_path(idx: int) -> str: return req.output_file_path(num_outputs, idx) + image_bytes = [] if req.return_image_bytes else None output_batch.output_file_paths = save_outputs( output_batch.output, req.data_type, req.fps, - True, + req.save_output, build_output_path, audio=output_batch.audio, audio_sample_rate=output_batch.audio_sample_rate, + image_bytes_out=image_bytes, output_compression=req.output_compression, x264_preset=req.x264_preset, enable_frame_interpolation=req.enable_frame_interpolation, @@ -1309,6 +1318,7 @@ class GPUWorker(GPUWorkerPostTrainingMixin): upscaling_model_path=req.upscaling_model_path, upscaling_scale=req.upscaling_scale, ) + output_batch.output_image_bytes = image_bytes def _save_group_output_paths( self, @@ -1324,14 +1334,16 @@ class GPUWorker(GPUWorkerPostTrainingMixin): ) first_req = reqs[0] + image_bytes = [] if first_req.return_image_bytes else None output_batch.output_file_paths = save_outputs( output_batch.output, first_req.data_type, first_req.fps, - True, + first_req.save_output, lambda idx: output_requests[idx].output_file_path(), audio=output_batch.audio, audio_sample_rate=output_batch.audio_sample_rate, + image_bytes_out=image_bytes, output_compression=first_req.output_compression, x264_preset=first_req.x264_preset, enable_frame_interpolation=first_req.enable_frame_interpolation, @@ -1342,6 +1354,7 @@ class GPUWorker(GPUWorkerPostTrainingMixin): upscaling_model_path=first_req.upscaling_model_path, upscaling_scale=first_req.upscaling_scale, ) + output_batch.output_image_bytes = image_bytes @staticmethod def _validate_group_forward_reqs(reqs: list[Req]) -> None: @@ -1351,6 +1364,7 @@ class GPUWorker(GPUWorkerPostTrainingMixin): "save_output", "return_frames", "return_file_paths_only", + "return_image_bytes", "data_type", "fps", "output_compression", diff --git a/python/sglang/multimodal_gen/runtime/managers/scheduler.py b/python/sglang/multimodal_gen/runtime/managers/scheduler.py index 1cce471951..7e6fc056b6 100644 --- a/python/sglang/multimodal_gen/runtime/managers/scheduler.py +++ b/python/sglang/multimodal_gen/runtime/managers/scheduler.py @@ -1162,6 +1162,9 @@ class Scheduler( output_file_paths=self._slice_batched_value( output_batch.output_file_paths, start, end, total_items ), + output_image_bytes=self._slice_batched_value( + output_batch.output_image_bytes, start, end, total_items + ), metrics=metrics, noise_pred=self._slice_batched_value( output_batch.noise_pred, start, end, total_items diff --git a/python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py b/python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py index 2113b00ce1..8c721573ea 100644 --- a/python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py +++ b/python/sglang/multimodal_gen/runtime/pipelines_core/schedule_batch.py @@ -484,6 +484,8 @@ class OutputBatch: trajectory_decoded: list[torch.Tensor] | None = None error: str | None = None output_file_paths: list[str] | None = None + # encoded image per output when the request sets return_image_bytes + output_image_bytes: list[bytes | None] | None = None # Decoded LiDAR of a joint camera/LiDAR request: file paths and metadata, # plus range_m/intensity/validity arrays when the client asked for frames. lidar: dict[str, Any] | None = None @@ -505,6 +507,7 @@ class OutputBatch: self.rollout_trajectory_data = None self.trajectory_decoded = None self.output_file_paths = None + self.output_image_bytes = None self.lidar = None self.raw_frame_batches = None self.noise_pred = None diff --git a/python/sglang/multimodal_gen/test/unit/test_image_response_bytes.py b/python/sglang/multimodal_gen/test/unit/test_image_response_bytes.py new file mode 100644 index 0000000000..3ee2815a4c --- /dev/null +++ b/python/sglang/multimodal_gen/test/unit/test_image_response_bytes.py @@ -0,0 +1,256 @@ +"""Image responses carry the bytes encoded on the output rank instead of reading a file back.""" + +import base64 +import os +from io import BytesIO +from types import SimpleNamespace +from unittest.mock import AsyncMock + +import imageio +import numpy as np +import pytest +import torch +from fastapi import FastAPI +from fastapi.testclient import TestClient +from PIL import Image + +from sglang.multimodal_gen.configs.sample.sampling_params import ( + DataType, + SamplingParams, +) +from sglang.multimodal_gen.runtime.entrypoints.openai import image_api +from sglang.multimodal_gen.runtime.entrypoints.utils import ( + MaterializedOutput, + save_materialized_output, + save_outputs, +) +from sglang.multimodal_gen.runtime.managers.gpu_worker import GPUWorker +from sglang.multimodal_gen.runtime.managers.scheduler import Scheduler +from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import ( + OutputBatch, + Req, +) + + +def _frame(channels: int) -> np.ndarray: + shape = (17, 23) if channels == 0 else (17, 23, channels) + return np.random.default_rng(channels).integers(0, 256, shape, dtype=np.uint8) + + +def _decode(data: bytes) -> np.ndarray: + with Image.open(BytesIO(data)) as image: + return np.asarray(image) + + +def _uint8_hwc(output: torch.Tensor) -> np.ndarray: + return (output * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).numpy() + + +def _encode(frame: np.ndarray, path: str, **kwargs) -> bytes: + return save_materialized_output( + MaterializedOutput(sample=None, frames=[frame]), + DataType.IMAGE, + path, + return_image_bytes=True, + **kwargs, + ) + + +# channels 0 is a 2-D grayscale frame, 1 a single-channel HWC frame +@pytest.mark.parametrize("channels", [0, 1, 3, 4]) +@pytest.mark.parametrize("output_compression", [None, 75, 100]) +def test_returned_png_holds_the_source_pixels_and_writes_nothing( + tmp_path, channels, output_compression +): + frame = _frame(channels) + + data = _encode( + frame, + str(tmp_path / "out.png"), + save_output=False, + output_compression=output_compression, + ) + + np.testing.assert_array_equal(_decode(data), frame.reshape(17, 23, -1).squeeze()) + assert list(tmp_path.iterdir()) == [] + + +@pytest.mark.parametrize("extension", ["png", "jpg", "webp"]) +def test_saved_file_holds_the_returned_bytes(tmp_path, extension): + path = tmp_path / f"out.{extension}" + + data = _encode(_frame(3), str(path)) + + assert path.read_bytes() == data + + +@pytest.mark.parametrize("extension", ["jpg", "webp"]) +@pytest.mark.parametrize("output_compression", [None, 90]) +def test_lossy_formats_keep_the_file_writer_bytes( + tmp_path, extension, output_compression +): + frame = _frame(3) + reference = tmp_path / f"reference.{extension}" + imageio.imwrite( + reference, + frame, + quality=75 if output_compression is None else output_compression, + ) + + data = _encode( + frame, + str(tmp_path / f"out.{extension}"), + save_output=False, + output_compression=output_compression, + ) + + assert data == reference.read_bytes() + + +def test_save_outputs_returns_one_image_per_output(tmp_path): + outputs = [torch.rand(3, 8, 8), torch.rand(3, 8, 8)] + image_bytes = [] + + paths = save_outputs( + outputs, + DataType.IMAGE, + 1, + False, + lambda idx: str(tmp_path / f"out_{idx}.png"), + image_bytes_out=image_bytes, + ) + + assert paths == [str(tmp_path / "out_0.png"), str(tmp_path / "out_1.png")] + for output, data in zip(outputs, image_bytes, strict=True): + np.testing.assert_array_equal(_decode(data), _uint8_hwc(output)) + assert list(tmp_path.iterdir()) == [] + + +def _image_req(tmp_path, *, save_output: bool, return_image_bytes: bool) -> Req: + return Req( + sampling_params=SamplingParams( + data_type=DataType.IMAGE, + save_output=save_output, + return_image_bytes=return_image_bytes, + output_path=str(tmp_path), + output_file_name="out.png", + ) + ) + + +@pytest.mark.parametrize( + ("save_output", "return_image_bytes", "encodes"), + [ + (True, False, True), + (False, True, True), + (True, True, True), + (False, False, False), + ], +) +def test_output_rank_encodes_when_saving_or_returning_bytes( + tmp_path, save_output, return_image_bytes, encodes +): + req = _image_req( + tmp_path, save_output=save_output, return_image_bytes=return_image_bytes + ) + + assert GPUWorker._encodes_on_output_rank(req) is encodes + + +@pytest.mark.parametrize("save_output", [False, True]) +def test_worker_returns_image_bytes_and_writes_only_when_saving(tmp_path, save_output): + req = _image_req(tmp_path, save_output=save_output, return_image_bytes=True) + output = torch.rand(3, 8, 8) + batch = OutputBatch(output=[output]) + + GPUWorker._save_output_paths(SimpleNamespace(is_output_rank=True), req, batch) + + path = tmp_path / "out.png" + assert batch.output_file_paths == [str(path)] + (data,) = batch.output_image_bytes + np.testing.assert_array_equal(_decode(data), _uint8_hwc(output)) + assert path.exists() == save_output + if save_output: + assert path.read_bytes() == data + + +def test_worker_without_image_bytes_request_returns_none(tmp_path): + req = _image_req(tmp_path, save_output=True, return_image_bytes=False) + batch = OutputBatch(output=[torch.rand(3, 8, 8)]) + + GPUWorker._save_output_paths(SimpleNamespace(is_output_rank=True), req, batch) + + assert batch.output_image_bytes is None + assert (tmp_path / "out.png").exists() + + +def test_dynamic_batch_split_keeps_each_requests_image_bytes(): + scheduler = object.__new__(Scheduler) + reqs = [Req(sampling_params=SamplingParams()) for _ in range(2)] + + outputs = scheduler._split_batched_output( + OutputBatch( + output_file_paths=["a.png", "b.png"], output_image_bytes=[b"a", b"b"] + ), + reqs, + ) + + assert [output.output_image_bytes for output in outputs] == [[b"a"], [b"b"]] + + +@pytest.mark.parametrize("endpoint", ["generations", "edits"]) +@pytest.mark.parametrize("persistent", [False, True]) +def test_b64_response_is_the_returned_bytes( + monkeypatch, tmp_path, endpoint, persistent +): + output_path = str(tmp_path / "outputs") if persistent else None + monkeypatch.setattr( + image_api, + "get_global_server_args", + lambda: SimpleNamespace(output_path=output_path, input_save_path=None), + ) + monkeypatch.setattr( + image_api, "resolve_sampling_params_cls", lambda _: SamplingParams + ) + monkeypatch.setattr(image_api, "maybe_enhance_prompt", AsyncMock(return_value="p")) + monkeypatch.setattr(image_api.cloud_storage, "is_enabled", lambda: False) + captured = {} + + def build(request_id, **kwargs): + captured.update(kwargs) + return SamplingParams() + + monkeypatch.setattr(image_api, "_build_request_sampling_params", build) + monkeypatch.setattr( + image_api, "prepare_request", lambda **_: SimpleNamespace(extra={}) + ) + png = BytesIO() + Image.fromarray(_frame(3)).save(png, format="PNG") + png = png.getvalue() + + async def generate(_client, _batch): + # no file exists at the returned path; the response must not need one + path = os.path.join(captured["output_path"], captured["output_file_name"]) + return [path], OutputBatch(output_image_bytes=[png]) + + monkeypatch.setattr(image_api, "process_generation_batch", generate) + app = FastAPI() + app.include_router(image_api.router) + with TestClient(app) as client: + if endpoint == "generations": + response = client.post( + "/v1/images/generations", + json={"prompt": "p", "response_format": "b64_json"}, + ) + else: + response = client.post( + "/v1/images/edits", + data={"prompt": "p", "response_format": "b64_json"}, + files={"image": ("reference.png", png, "image/png")}, + ) + + assert response.status_code == 200, response.text + (item,) = response.json()["data"] + assert base64.b64decode(item["b64_json"]) == png + assert captured["return_image_bytes"] is True + assert captured["save_output"] is persistent diff --git a/python/sglang/multimodal_gen/test/unit/test_multiple_task_types.py b/python/sglang/multimodal_gen/test/unit/test_multiple_task_types.py index 0f9a163bb8..67df5f315b 100644 --- a/python/sglang/multimodal_gen/test/unit/test_multiple_task_types.py +++ b/python/sglang/multimodal_gen/test/unit/test_multiple_task_types.py @@ -208,9 +208,7 @@ def http_client(monkeypatch, tmp_path, request): async def generate(client, req, **kwargs): admitted.append(req) - path = req.output_file_path() - Image.new("RGB", (64, 64)).save(path) - return [path], OutputBatch() + return [req.output_file_path()], OutputBatch(output_image_bytes=[png_bytes()]) async def upload(paths): return [None] * len(paths) diff --git a/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py b/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py index 4fc3ed3b0a..7edbaf22c0 100644 --- a/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py +++ b/python/sglang/multimodal_gen/test/unit/test_openai_image_api.py @@ -237,20 +237,22 @@ def test_response_resize_prefers_requested_size_over_generation_canvas(): assert _get_response_resize(glm_sampling) == "1280x720" -def test_response_resize_uses_actual_generated_image_size(tmp_path): - output_path = tmp_path / "output.png" - Image.new("RGB", (1280, 736)).save(output_path) +def _png_bytes(size: tuple[int, int]) -> bytes: + buffer = BytesIO() + Image.new("RGB", size).save(buffer, format="PNG") + return buffer.getvalue() + + +def test_response_resize_uses_actual_generated_image_size(): glm_sampling = GlmImageSamplingParams(image_path="input.png") - assert _get_response_resize(glm_sampling, str(output_path)) == "1280x736" + assert _get_response_resize(glm_sampling, _png_bytes((1280, 736))) == "1280x736" -def test_response_resize_prefers_final_output_over_sampling_canvas(tmp_path): - output_path = tmp_path / "upscaled.png" - Image.new("RGB", (2560, 1472)).save(output_path) +def test_response_resize_prefers_final_output_over_sampling_canvas(): glm_sampling = GlmImageSamplingParams(width=1280, height=736) - assert _get_response_resize(glm_sampling, str(output_path)) == "2560x1472" + assert _get_response_resize(glm_sampling, _png_bytes((2560, 1472))) == "2560x1472" def test_url_response_uses_variant_fallback_urls_for_multiple_persistent_outputs(): diff --git a/python/sglang/multimodal_gen/test/unit/test_output_saving.py b/python/sglang/multimodal_gen/test/unit/test_output_saving.py index 90c12f8f64..857816386c 100644 --- a/python/sglang/multimodal_gen/test/unit/test_output_saving.py +++ b/python/sglang/multimodal_gen/test/unit/test_output_saving.py @@ -43,7 +43,8 @@ def test_png_output_saving_preserves_pixels(tmp_path, output_compression): @pytest.mark.parametrize( - ("output_compression", "expected_compress_level"), [(None, 1), (0, 0), (75, 1)] + ("output_compression", "expected_compress_level"), + [(None, 0), (0, 0), (75, 0), (100, 9)], ) def test_png_output_saving_uses_fast_pillow_path( tmp_path, monkeypatch, output_compression, expected_compress_level @@ -122,17 +123,16 @@ def test_warm_image_writer_takes_the_default_jpeg_path(tmp_path, monkeypatch): written = [] imwrite = output_utils.imageio.imwrite - def imwrite_spy(path, frame, **kwargs): - written.append((path, kwargs)) - return imwrite(path, frame, **kwargs) + def imwrite_spy(uri, frame, **kwargs): + written.append((uri, kwargs)) + return imwrite(uri, frame, **kwargs) monkeypatch.setattr(output_utils.imageio, "imwrite", imwrite_spy) - monkeypatch.setattr(output_utils.tempfile, "tempdir", str(tmp_path)) + monkeypatch.chdir(tmp_path) output_utils.warm_image_writer() - assert len(written) == 1 - assert written[0][0].endswith(".jpg") and written[0][1] == {"quality": 75} + assert written == [("", {"format": ".jpg", "quality": 75})] assert list(tmp_path.iterdir()) == [] diff --git a/python/sglang/multimodal_gen/test/unit/test_prompt_enhancement.py b/python/sglang/multimodal_gen/test/unit/test_prompt_enhancement.py index 9f2d5fe659..fa6ee04530 100644 --- a/python/sglang/multimodal_gen/test/unit/test_prompt_enhancement.py +++ b/python/sglang/multimodal_gen/test/unit/test_prompt_enhancement.py @@ -369,7 +369,8 @@ def server(monkeypatch, tmp_path): path = tmp_path / f"{batch.request_id}_{idx}.png" Image.new("RGB", (16, 16), "red").save(path) paths.append(str(path)) - return OutputBatch(output_file_paths=paths) + image_bytes = [open(path, "rb").read() for path in paths] + return OutputBatch(output_file_paths=paths, output_image_bytes=image_bytes) monkeypatch.setattr(async_scheduler_client, "forward", forward) app = http_server.create_app(args)