MMnode/tests/test_llm_api.py
Z User 0c4987d090 T2V resolves to the same value as R2V; loader shows a single model
- T2V selections (editor default mode, explicit [start-end,t2v] override
  tags, raw t2v values) now resolve to r2v in every task-type resolver
  (h3_task_type, _multitrack_task_type, frontend getMultiTrackTaskType);
  h3_generation_mode maps raw t2v to reference conditioning as belt and
  braces. Reference-mode with zero reference media renders text-only
  locally; the cloud path falls back to its native t2va request instead
  of raising. i2v/l2v/v2v/edit flows unchanged.
- MoxieMultimediaLoader now presents a single model picker: LoRA, video
  VAE, audio VAE, and CLIP widgets removed and auto-selected from the
  pack's models/ folders (first sorted file, loud error when missing,
  LoRA applied at strength 1.0 when bundled). Outputs and load order
  unchanged; saved workflows keep working (extra widget values ignored).

Verified: py_compile; scripts/test_t2v_r2v_and_loader.py 50/50;
frontend vitest 566/567 (one pre-existing env failure on HEAD);
bun run build; scripts/test_rtx_upscale_integration.py all pass.
2026-09-27 05:50:35 +00:00

917 lines
26 KiB
Python

import importlib.util
import base64
import io
import json
import sys
from pathlib import Path
import pytest
import torch
from PIL import Image
def _load_module():
module_name = "easy_media_llm_api_for_tests"
sys.modules.pop(module_name, None)
module_path = Path(__file__).parents[1] / "utils" / "llm_api.py"
spec = importlib.util.spec_from_file_location(module_name, module_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
assert spec.loader is not None
spec.loader.exec_module(module)
return module
class _Response:
def __init__(self, payload):
self.payload = payload
def __enter__(self):
return self
def __exit__(self, *args):
return False
def read(self):
return json.dumps(self.payload).encode("utf-8")
def _png_data_uri(width=256, height=256):
buffer = io.BytesIO()
Image.new("RGB", (width, height)).save(buffer, format="PNG")
return "data:image/png;base64," + base64.b64encode(buffer.getvalue()).decode()
def test_minimax_length_to_seconds_rounds_to_nearest_and_clamps():
module = _load_module()
assert module.minimax_length_to_seconds(1) == 4
assert module.minimax_length_to_seconds(49) == 4
assert module.minimax_length_to_seconds(50) == 4
assert module.minimax_length_to_seconds(124) == 5
assert module.minimax_length_to_seconds(10_000) == 15
def test_prompt_enhancer_model_options_match_node_contract():
module = _load_module()
assert module.PROMPT_ENHANCER_MODELS == [
"h3-context-ir (海螺官方)",
"doubao-seed-2-0-pro-260215 (火山引擎)",
"glm-5v-turbo (智谱)",
"bytedance/doubao-seed-2.0-pro (RunningHub)",
"glm-5v-turbo (RunningHub)",
"llama.cpp (本地)",
]
def test_third_party_video_url_capabilities_match_provider_documentation():
module = _load_module()
assert module.prompt_enhancer_supports_video_url(module.VOLCENGINE_MODEL) is True
assert module.prompt_enhancer_supports_video_url(module.ZHIPU_MODEL) is True
assert module.prompt_enhancer_supports_video_url(module.RUNNINGHUB_DOUBAO_MODEL)
assert module.prompt_enhancer_supports_video_url(module.RUNNINGHUB_GLM_MODEL)
def test_llamacpp_max_tokens_widget_limits():
module = _load_module()
assert module.PROMPT_ENHANCER_MAX_TOKENS[module.LLAMACPP_MODEL] == (512, 768)
@pytest.mark.parametrize(
("model_name", "config_key"),
[
("MINIMAX_MODEL", "MINIMAX_API_KEY"),
("VOLCENGINE_MODEL", "VOLCENGINE_API_KEY"),
("ZHIPU_MODEL", "BIGMODEL_API_KEY"),
("RUNNINGHUB_DOUBAO_MODEL", "RUNNINGHUB_API_KEY"),
("RUNNINGHUB_GLM_MODEL", "RUNNINGHUB_API_KEY"),
],
)
def test_client_reads_empty_api_key_from_vendor_config(
tmp_path,
monkeypatch,
model_name,
config_key,
):
module = _load_module()
config_path = tmp_path / "config.yaml"
config_path.write_text(f"{config_key}: config-secret\n", encoding="utf-8")
for environment_name in (
"MINIMAX_API_KEY",
"VOLCENGINE_API_KEY",
"BIGMODEL_API_KEY",
"RUNNINGHUB_API_KEY",
"ARK_API_KEY",
"ZHIPU_API_KEY",
):
monkeypatch.delenv(environment_name, raising=False)
client = module.PromptEnhancerClient(
getattr(module, model_name),
"",
config_path=config_path,
)
assert client.api_key == "config-secret"
def test_explicit_api_key_takes_priority_over_config(tmp_path):
module = _load_module()
config_path = tmp_path / "config.yaml"
config_path.write_text("MINIMAX_API_KEY: config-secret\n", encoding="utf-8")
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"widget-secret",
config_path=config_path,
)
assert client.api_key == "widget-secret"
def test_minimax_upload_configuration_is_fixed(tmp_path):
module = _load_module()
config_path = tmp_path / "config.yaml"
config_path.write_text(
"\n".join(
[
"MINIMAX_UPLOAD_ENDPOINT: https://upload.example.test/files",
"MINIMAX_UPLOAD_PURPOSE: should-not-be-used",
]
),
encoding="utf-8",
)
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
config_path=config_path,
)
assert client.upload_endpoint == "https://api.minimaxi.com/v1/files/upload"
assert client.upload_purpose == "video_generation_input"
def test_missing_api_key_points_to_vendor_config_key(tmp_path, monkeypatch):
module = _load_module()
config_path = tmp_path / "config.yaml"
config_path.write_text("VOLCENGINE_API_KEY:\n", encoding="utf-8")
for environment_name in ("VOLCENGINE_API_KEY", "ARK_API_KEY"):
monkeypatch.delenv(environment_name, raising=False)
with pytest.raises(
ValueError,
match=(
"Enter apikey or configure VOLCENGINE_API_KEY "
"in config.yaml"
),
):
module.PromptEnhancerClient(
module.VOLCENGINE_MODEL,
"",
config_path=config_path,
)
def test_image_tensor_data_uris_flattens_batches():
module = _load_module()
images = torch.zeros(2, 4, 5, 3)
encoded = module.image_tensor_data_uris([images, torch.ones(4, 5, 3)])
assert len(encoded) == 3
assert all(value.startswith("data:image/png;base64,") for value in encoded)
def test_image_tensor_data_uris_limits_third_party_images_to_two_megapixels():
module = _load_module()
encoded = module.image_tensor_data_uris(
torch.zeros(1, 1200, 2000, 3),
max_pixels=2_000_000,
)
image_bytes = base64.b64decode(encoded[0].split(",", 1)[1])
with Image.open(io.BytesIO(image_bytes)) as image:
assert image.width * image.height <= 2_000_000
def test_video_frame_data_uris_samples_at_most_24_frames():
module = _load_module()
class Video:
def get_components(self):
return type("Components", (), {"images": torch.zeros(30, 8, 8, 3)})()
encoded = module.video_frame_data_uris([Video()])
assert len(encoded) == 24
assert all(value.startswith("data:image/png;base64,") for value in encoded)
def test_zhipu_preserves_public_video_url_without_sampling_frames():
module = _load_module()
class Video:
def get_stream_source(self):
return "https://example.com/reference.mp4"
def get_components(self):
raise AssertionError("public video URL must not be sampled")
assert module.prompt_enhancer_video_inputs(module.ZHIPU_MODEL, [Video()]) == [
"https://example.com/reference.mp4"
]
def test_zhipu_samples_local_video_when_only_public_urls_are_supported():
module = _load_module()
class Video:
def get_stream_source(self):
return "/tmp/reference.mp4"
def get_components(self):
return type("Components", (), {"images": torch.zeros(30, 8, 8, 3)})()
encoded = module.prompt_enhancer_video_inputs(module.ZHIPU_MODEL, [Video()])
assert len(encoded) == 24
assert all(value.startswith("data:image/png;base64,") for value in encoded)
def test_volcengine_uses_native_data_uri_for_local_video():
module = _load_module()
class Video:
def get_stream_source(self):
return b"video-bytes"
def get_container_format(self):
return "mp4"
def get_components(self):
raise AssertionError("native video data URI must not be sampled")
encoded = module.prompt_enhancer_video_inputs(module.VOLCENGINE_MODEL, [Video()])
assert len(encoded) == 1
assert encoded[0].startswith("data:video/mp4;base64,")
def test_runninghub_uses_native_video_data_uri_with_official_limits(monkeypatch):
module = _load_module()
calls = []
class Video:
def get_stream_source(self):
return b"video-bytes"
monkeypatch.setattr(
module,
"video_data_uris",
lambda values, **kwargs: calls.append(kwargs)
or ["data:video/mp4;base64,AAAA"],
)
encoded = module.prompt_enhancer_video_inputs(
module.RUNNINGHUB_DOUBAO_MODEL,
[Video()],
)
assert encoded == ["data:video/mp4;base64,AAAA"]
assert calls == [{"max_bytes": 10 * 1024 * 1024, "max_duration": 15}]
def test_video_data_uri_serializes_active_trim_instead_of_original_stream():
module = _load_module()
class Video:
def get_stream_source(self):
return b"original-video"
def get_active_trim_window(self):
return 2.0, 5.0
def save_to(self, output_path):
Path(output_path).write_bytes(b"trimmed-video")
encoded = module.video_data_uris([Video()])
assert base64.b64decode(encoded[0].split(",", 1)[1]) == b"trimmed-video"
def test_video_data_uri_enforces_duration_even_when_file_is_under_size_limit(monkeypatch):
module = _load_module()
calls = []
class Video:
def get_stream_source(self):
return b"small-long-video"
monkeypatch.setattr(module, "_probe_video_duration", lambda _source, _data: 20.0)
monkeypatch.setattr(
module,
"_limit_video_for_data_uri",
lambda source, data, **kwargs: calls.append((source, data, kwargs)) or b"limited",
)
encoded = module.video_data_uris(
[Video()],
max_bytes=10 * 1024 * 1024,
max_duration=15,
)
assert calls == [(
b"small-long-video",
b"small-long-video",
{"max_bytes": 10 * 1024 * 1024, "max_duration": 15},
)]
assert base64.b64decode(encoded[0].split(",", 1)[1]) == b"limited"
@pytest.mark.parametrize(
("task_type", "expected_mode", "image_count", "video_count", "audio_count"),
[
("t2v", "t2va", 0, 0, 0),
("i2v", "i2va", 2, 0, 0),
("l2v", "i2va", 1, 0, 0),
("v2v", "r2va", 2, 1, 1),
("r2v", "r2va", 2, 1, 1),
# Reference-mode with zero media falls back to the cloud's native
# text-only mode (T2V selections resolve to r2v upstream).
("r2v", "t2va", 0, 0, 0),
("vi2v", "r2va", 2, 1, 1),
("rv2v", "r2va", 2, 1, 1),
],
)
def test_h3_task_type_selects_request_mode_and_media(
task_type,
expected_mode,
image_count,
video_count,
audio_count,
):
module = _load_module()
mode, images, videos, audios = module.PromptEnhancerClient._h3_media_for_task_type(
task_type,
["image-1", "image-2"],
["video-1"],
["audio-1"],
)
assert mode == expected_mode
assert len(images) == image_count
assert len(videos) == video_count
assert len(audios) == audio_count
def test_h3_i2va_roles_follow_task_type_and_image_count():
module = _load_module()
i2v_content = module.PromptEnhancerClient._h3_content(
"Prompt", "i2v", ["first", "last"], [], []
)
l2v_content = module.PromptEnhancerClient._h3_content(
"Prompt", "l2v", ["last"], [], []
)
assert [item.get("role") for item in i2v_content[1:]] == [
"first_frame",
"last_frame",
]
assert l2v_content[1]["role"] == "last_frame"
def test_h3_r2va_assigns_roles_by_media_type():
module = _load_module()
content = module.PromptEnhancerClient._h3_content(
"Prompt",
"rv2v",
["image"],
["video"],
["audio"],
)
assert [item.get("role") for item in content[1:]] == [
"reference_image",
"reference_video",
"reference_audio",
]
def test_h3_rejects_image_dimensions_before_upload():
module = _load_module()
client = module.PromptEnhancerClient(module.MINIMAX_MODEL, "secret")
with pytest.raises(ValueError, match="between 256 and 5760"):
client._upload_h3_media(_png_data_uri(128, 256), "image", 1, None)
def test_minimax_async_request_returns_task_id_and_maps_ratio():
module = _load_module()
requests = []
log_calls = []
def opener(request, timeout):
requests.append((request, timeout))
if request.full_url.endswith("/v1/files/upload"):
return _Response({"file": {"file_id": 101}})
return _Response({"task_id": "task-123"})
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=opener,
)
result = client.enhance(
system_prompt="System instructions that H3 must ignore. " * 300,
user_prompt="A dancer turns.",
task_type="r2v",
duration=2,
ratio="9:19",
seed=7,
image_urls=[_png_data_uri()],
return_async=True,
file_count=2,
request_logger=lambda node_name, message=None: log_calls.append(
(node_name, message)
),
)
assert result.prompt == ""
assert result.task_id == "task-123"
assert result.file_ids == "101"
upload_request, upload_timeout = requests[0]
assert upload_timeout == 300.0
assert upload_request.full_url == "https://api.minimaxi.com/v1/files/upload"
assert b"video_generation_input" in upload_request.data
request, timeout = requests[1]
assert timeout == 300.0
assert request.full_url == "https://api.minimaxi.com/v2/h3_context_ir"
payload = json.loads(request.data)
assert payload["duration"] == 4
assert payload["ratio"] == "9:16"
assert payload["content"][0] == {
"type": "text",
"text": "A dancer turns.",
}
assert payload["content"][1]["role"] == "reference_image"
assert payload["content"][1]["image_url"]["url"] == "mm_file://101"
assert request.headers["Authorization"] == "Bearer secret"
messages = [message for _node_name, message in log_calls]
assert messages[0].startswith("H3 uploading image #1")
assert messages[1] == "H3 upload image #1 succeeded: file_id=101"
assert "images=1, videos=0, audios=0, files=2" in messages[2]
assert messages[3] == "H3 create request succeeded: task_id=task-123"
def test_minimax_rejects_only_user_prompt_over_7000_characters():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=lambda request, timeout: requests.append(request),
)
with pytest.raises(ValueError, match="cannot exceed 7000 characters"):
client.enhance(
system_prompt="Ignored system instructions.",
user_prompt="x" * 7001,
task_type="t2v",
duration=5,
ratio="16:9",
seed=0,
)
assert requests == []
def test_minimax_returns_uploaded_file_ids_in_media_order():
module = _load_module()
upload_ids = iter([101, 202, 303])
def opener(request, timeout):
if request.full_url.endswith("/v1/files/upload"):
return _Response({"file": {"file_id": next(upload_ids)}})
return _Response({"task_id": "task-files"})
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=opener,
)
result = client.enhance(
system_prompt="",
user_prompt="Use all references.",
task_type="r2v",
duration=5,
ratio="adaptive",
seed=0,
image_urls=[_png_data_uri()],
video_urls=["data:video/mp4;base64,AAAA"],
audio_urls=["data:audio/wav;base64,AAAA"],
return_async=True,
)
assert result.file_ids == "101,202,303"
def test_minimax_rejects_empty_user_prompt_before_upload_or_create_request():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=lambda request, timeout: requests.append(request),
)
with pytest.raises(ValueError, match="user_prompt cannot be empty"):
client.enhance(
system_prompt="Ignored system instructions.",
user_prompt=" ",
task_type="r2v",
duration=5,
ratio="adaptive",
seed=0,
image_urls=[_png_data_uri()],
)
assert requests == []
def test_minimax_sync_request_polls_every_five_seconds():
module = _load_module()
payloads = iter(
[
{"file": {"file_id": 404}},
{"task_id": "task-456"},
{"task": {"status": "queued"}},
{
"task": {
"status": "succeeded",
"content": {"prompt": "```text\nEnhanced.\n```"},
}
},
]
)
sleeps = []
statuses = []
log_messages = []
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=lambda request, timeout: _Response(next(payloads)),
sleeper=sleeps.append,
)
result = client.enhance(
system_prompt="",
user_prompt="A city at night.",
task_type="i2v",
duration=5,
ratio="adaptive",
seed=0,
image_urls=[_png_data_uri()],
poll_interval=5.0,
poll_callback=statuses.append,
request_logger=lambda _name, message=None: log_messages.append(message),
)
assert result.prompt == "Enhanced."
assert result.task_id == "task-456"
assert result.file_ids == "404"
assert sleeps == [5.0, 5.0]
assert statuses == ["queued", "succeeded"]
assert log_messages[-4:] == [
"H3 create request succeeded: task_id=task-456",
"H3 polling result: task_id=task-456, status=queued",
"H3 polling result: task_id=task-456, status=succeeded",
"H3 task succeeded: task_id=task-456",
]
def test_minimax_sync_polling_defaults_to_ten_minutes():
module = _load_module()
assert module.PromptEnhancerClient.enhance.__kwdefaults__["poll_timeout"] == 600.0
def test_minimax_sync_polling_stops_at_overall_timeout():
module = _load_module()
payloads = iter(
[
{"task_id": "task-timeout"},
{"task": {"status": "queued"}},
]
)
now = [0.0]
def sleep(seconds):
now[0] += seconds
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=lambda request, timeout: _Response(next(payloads)),
sleeper=sleep,
clock=lambda: now[0],
)
with pytest.raises(
module.PromptEnhancerApiError,
match="timed out after 6s: task-timeout",
):
client.enhance(
system_prompt="",
user_prompt="Prompt",
task_type="t2v",
duration=5,
ratio="16:9",
seed=0,
poll_interval=5,
poll_timeout=6,
)
def test_openai_compatible_request_extracts_prompt_without_task_id():
module = _load_module()
requests = []
def opener(request, timeout):
requests.append(request)
return _Response({
"choices": [{"message": {"content": " ```text\nBetter prompt.\n``` "}}]
})
client = module.PromptEnhancerClient(
module.ZHIPU_MODEL,
"secret",
opener=opener,
)
result = client.enhance(
system_prompt="You enhance prompts.",
user_prompt="A dog runs.",
task_type="i2v",
duration=6,
ratio="16:9",
seed=42,
image_urls=["data:image/png;base64,AAAA"],
return_async=True,
)
assert result.prompt == "Better prompt."
assert result.task_id == ""
payload = json.loads(requests[0].data)
assert payload["seed"] == 42
assert payload["messages"][0] == {
"role": "system",
"content": "You enhance prompts.",
}
assert payload["messages"][1]["content"][1]["type"] == "image_url"
def test_openai_compatible_request_maps_comfyui_seed_to_int32():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.ZHIPU_MODEL,
"secret",
opener=lambda request, timeout: (
requests.append(request)
or _Response({"choices": [{"message": {"content": "Enhanced"}}]})
),
)
client.enhance(
system_prompt="",
user_prompt="Prompt",
task_type="t2v",
duration=5,
ratio="16:9",
seed=715809353714956,
)
payload = json.loads(requests[0].data)
assert payload["seed"] == 1514229004
assert 0 <= payload["seed"] <= 0x7FFFFFFF
@pytest.mark.parametrize(
("prompt", "expected"),
[
("```text\nA cinematic prompt.\n```", "A cinematic prompt."),
(" ```text\r\nA cinematic prompt.\r\n``` ", "A cinematic prompt."),
("```json\n{\"prompt\": \"keep\"}\n```", "```json\n{\"prompt\": \"keep\"}\n```"),
("```text\nMissing closing fence", "```text\nMissing closing fence"),
("Plain prompt", "Plain prompt"),
],
)
def test_strip_text_code_fence_only_removes_complete_text_fence(prompt, expected):
module = _load_module()
assert module.strip_text_code_fence(prompt) == expected
def test_minimax_failed_task_is_logged():
module = _load_module()
payloads = iter(
[
{"task_id": "task-failed"},
{"task": {"status": "failed", "error": {"message": "bad media"}}},
]
)
log_messages = []
client = module.PromptEnhancerClient(
module.MINIMAX_MODEL,
"secret",
opener=lambda request, timeout: _Response(next(payloads)),
sleeper=lambda _seconds: None,
)
with pytest.raises(module.PromptEnhancerApiError, match="bad media"):
client.enhance(
system_prompt="",
user_prompt="Prompt",
task_type="t2v",
duration=5,
ratio="16:9",
seed=0,
request_logger=lambda _name, message=None: log_messages.append(message),
)
assert log_messages[-2:] == [
"H3 polling result: task_id=task-failed, status=failed",
"H3 task failed: task_id=task-failed, error=bad media",
]
def test_task_type_controls_openai_compatible_media_parts():
module = _load_module()
requests = []
def opener(request, timeout):
requests.append(request)
return _Response({"choices": [{"message": {"content": "Enhanced"}}]})
client = module.PromptEnhancerClient(module.ZHIPU_MODEL, "secret", opener=opener)
client.enhance(
system_prompt="",
user_prompt="Text only",
task_type="t2v",
duration=5,
ratio="16:9",
seed=0,
image_urls=["data:image/png;base64,AAAA"],
video_urls=["data:video/mp4;base64,AAAA"],
audio_urls=["data:audio/wav;base64,AAAA"],
)
payload = json.loads(requests[0].data)
content = payload["messages"][0]["content"]
assert [part["type"] for part in content] == ["text"]
assert payload["max_tokens"] == 65536
def test_third_party_max_tokens_is_capped_by_model_limit():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.VOLCENGINE_MODEL,
"secret",
opener=lambda request, timeout: (
requests.append(request)
or _Response({"choices": [{"message": {"content": "Enhanced"}}]})
),
)
client.enhance(
system_prompt="",
user_prompt="Enhance this",
task_type="t2v",
duration=5,
ratio="adaptive",
seed=0,
max_tokens=200000,
)
assert json.loads(requests[0].data)["max_tokens"] == 131072
def test_native_video_provider_uses_public_video_url_and_omits_audio():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.ZHIPU_MODEL,
"secret",
opener=lambda request, timeout: (
requests.append(request)
or _Response({"choices": [{"message": {"content": "Enhanced"}}]})
),
)
client.enhance(
system_prompt="",
user_prompt="Edit the video",
task_type="v2v",
duration=5,
ratio="16:9",
seed=0,
video_urls=["https://example.com/reference.mp4"],
audio_urls=["data:audio/wav;base64,AAAA"],
)
payload = json.loads(requests[0].data)
content = payload["messages"][0]["content"]
assert [part["type"] for part in content] == ["text", "video_url"]
def test_sampled_video_frames_remain_image_parts_for_native_provider():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.ZHIPU_MODEL,
"secret",
opener=lambda request, timeout: (
requests.append(request)
or _Response({"choices": [{"message": {"content": "Enhanced"}}]})
),
)
client.enhance(
system_prompt="",
user_prompt="Edit the video",
task_type="v2v",
duration=5,
ratio="16:9",
seed=0,
video_urls=["data:image/png;base64,AAAA"],
)
payload = json.loads(requests[0].data)
content = payload["messages"][0]["content"]
assert [part["type"] for part in content] == ["text", "image_url"]
def test_runninghub_uses_video_url_and_omits_unsupported_seed():
module = _load_module()
requests = []
client = module.PromptEnhancerClient(
module.RUNNINGHUB_GLM_MODEL,
"secret",
opener=lambda request, timeout: (
requests.append(request)
or _Response({"choices": [{"message": {"content": "Enhanced"}}]})
),
)
client.enhance(
system_prompt="",
user_prompt="Edit the video",
task_type="v2v",
duration=5,
ratio="adaptive",
seed=123,
video_urls=["data:video/mp4;base64,AAAA"],
)
payload = json.loads(requests[0].data)
assert [part["type"] for part in payload["messages"][0]["content"]] == [
"text",
"video_url",
]
assert "seed" not in payload
def test_http_error_is_normalized_with_provider_message():
module = _load_module()
def opener(request, timeout):
raise module.urllib.error.HTTPError(
request.full_url,
429,
"Too Many Requests",
{},
io.BytesIO(b'{"error":{"message":"rate limited"}}'),
)
client = module.PromptEnhancerClient(
module.ZHIPU_MODEL,
"secret",
opener=opener,
)
with pytest.raises(module.PromptEnhancerApiError, match="HTTP 429: rate limited"):
client.enhance(
system_prompt="",
user_prompt="Prompt",
task_type="t2v",
duration=5,
ratio="16:9",
seed=0,
)