import json import math import re TIMELINE_OVERRIDE_TYPES = {"flf", "fmlf", "ref"} MINIMAX_PROMPT_OVERRIDE_TYPE = "minimax_prompt_override" MINIMAX_DEFAULT_GENERATION_TYPE = "r2v" MINIMAX_DEFAULT_CONTINUITY_MODE = "shot" MINIMAX_GENERATION_TYPES = {"r2v", "t2v", "i2v", "v2v", "l2v"} MINIMAX_CONTINUITY_MODES = {"shot", "context", "context_swap"} _IMAGE_REF_RE = re.compile(r'@(?:图像|图片|图|image|img)(\d+)', re.IGNORECASE) _AUDIO_REF_RE = re.compile(r'@(?:audio|auido|音频)(\d+)', re.IGNORECASE) _VIDEO_REF_RE = re.compile(r'@(?:video|视频)(\d+)', re.IGNORECASE) _MINIMAX_REFERENCE_GROUPS = { "image": ( _IMAGE_REF_RE, re.compile(r"", re.IGNORECASE), ), "audio": ( _AUDIO_REF_RE, re.compile(r"", re.IGNORECASE), ), "video": ( _VIDEO_REF_RE, re.compile(r"", re.IGNORECASE), ), } _MINIMAX_REFERENCE_LABELS = { "image": "Picture", "audio": "Audio", "video": "Video", } _FRAME_RANGE_RE = re.compile( r'\[(\d+(?:\.\d+)?)(s?)-(\d+(?:\.\d+)?)(s?)(?:,([^\]]+))?\]', re.IGNORECASE, ) def _seconds_to_override_frame(seconds: float, frame_rate: int) -> int: if seconds <= 0: return 0 return math.ceil((seconds * frame_rate) / 4) * 4 def parse_override_segments( prompt_override, total_length: int = 121, frame_rate: int = 24, allowed_types: set[str] | None = None, allow_custom_types: bool = False, ) -> list[dict]: """Parse prompt_override (str with | separators, or list) into segment dicts.""" allowed_override_types = allowed_types or TIMELINE_OVERRIDE_TYPES if isinstance(prompt_override, list): parts = [ part.strip() for item in prompt_override for part in str(item).split('|') if part.strip() ] else: parts = [p.strip() for p in str(prompt_override).split('|') if p.strip()] segments: list[dict] = [] safe_total_length = max(1, int(total_length)) safe_frame_rate = max(1, int(frame_rate)) part_count = max(1, len(parts)) for part_idx, part in enumerate(parts): m = _FRAME_RANGE_RE.search(part) has_explicit_range = m is not None if m: is_seconds_range = bool(m.group(2) or m.group(4)) if is_seconds_range: start_seconds = float(m.group(1)) end_seconds = float(m.group(3)) start_frame = _seconds_to_override_frame(start_seconds, safe_frame_rate) end_frame = max(start_frame, _seconds_to_override_frame(end_seconds, safe_frame_rate)) else: start_frame = int(m.group(1)) end_frame = int(m.group(3)) seg_type = (m.group(5) or 'flf').strip().lower() else: start_frame = round(part_idx * safe_total_length / part_count) end_frame = round((part_idx + 1) * safe_total_length / part_count) - 1 seg_type = 'flf' if not allow_custom_types and seg_type not in allowed_override_types: seg_type = 'flf' image_indices = [int(r.group(1)) for r in _IMAGE_REF_RE.finditer(part)] audio_indices = [int(r.group(1)) for r in _AUDIO_REF_RE.finditer(part)] video_indices = [int(r.group(1)) for r in _VIDEO_REF_RE.finditer(part)] clean = _IMAGE_REF_RE.sub('', part) clean = _AUDIO_REF_RE.sub('', clean) clean = _VIDEO_REF_RE.sub('', clean) clean = _FRAME_RANGE_RE.sub('', clean) clean = clean.strip() segments.append({ 'start_frame': start_frame, 'end_frame': end_frame, 'type': seg_type, 'text': clean, 'image_indices': image_indices, 'audio_indices': audio_indices, 'video_indices': video_indices, '_has_explicit_range': has_explicit_range, }) return segments def prompt_override_has_frame_ranges(prompt_override) -> bool: if isinstance(prompt_override, list): parts = [ part for item in prompt_override for part in str(item).split('|') ] else: parts = str(prompt_override).split('|') return any(_FRAME_RANGE_RE.search(str(part)) for part in parts) def prompt_override_has_value(prompt_override) -> bool: if prompt_override is None: return False if isinstance(prompt_override, list): return any(str(item).strip() for item in prompt_override) return bool(str(prompt_override).strip()) def _multitrack_task_mode_from_override_type(seg_type: str) -> str: if seg_type == "l2v": return "l2v" if seg_type in ("ref", "r2v", "rv2v"): return "ref" if seg_type in ("fmlf", "v2v", "vi2v"): return "edit" return "default" def build_multitrack_data_from_prompt_override(base_data: dict, prompt_override) -> dict: frame_rate = float(base_data.get("frame_rate", 24.0) or 24.0) override_frame_rate = max(1, int(round(frame_rate))) total_length = int(base_data.get("total_length", 120) or 120) total_length = max(1, total_length) segments = parse_override_segments( prompt_override, total_length=total_length, frame_rate=override_frame_rate, allow_custom_types=True, ) task_segments: list[dict] = [] audio_segments_by_index: dict[int, list[dict]] = {} video_segments: list[dict] = [] max_end_frame = 0 max_timeline_end_frame = 0 for index, segment in enumerate(segments): start_frame = max(0, int(segment["start_frame"])) timeline_end_frame = int(segment["end_frame"]) if segment.get("_has_explicit_range") is True: end_frame = max(start_frame + 1, timeline_end_frame) else: end_frame = max(start_frame + 1, timeline_end_frame + 1) max_end_frame = max(max_end_frame, end_frame) max_timeline_end_frame = max(max_timeline_end_frame, timeline_end_frame) duration = max(0.0, (end_frame - start_frame) / frame_rate) images: list[dict] = [] for image_index in segment.get("image_indices", []): images.append({ "id": f"override-image-{index + 1}-{image_index}", "source_type": "slot", "slot_name": f"image{image_index}", "file_name": f"image{image_index}", }) task_content = { "media_type": "none", "task_mode": _multitrack_task_mode_from_override_type(str(segment.get("type", "flf"))), "images": images, "text": segment.get("text", ""), } task_type = str(segment.get("type", "")) if task_type and task_type not in TIMELINE_OVERRIDE_TYPES: task_content["task_type"] = task_type task_segments.append({ "id": f"override-task-{index + 1}", "start_frame": start_frame, "end_frame": end_frame, "color": "var(--multitrack-task-bg)", "content": task_content, }) audio_indices = segment.get("audio_indices", []) for audio_index in dict.fromkeys(int(value) for value in audio_indices): audio_segments_by_index.setdefault(audio_index, []).append({ "id": f"override-audio-{index + 1}-{audio_index}", "start_frame": start_frame, "end_frame": end_frame, "origin_start_frame": start_frame, "color": "var(--highlight)", "content": { "media_type": "audio", "source_type": "slot", "slot_name": f"audio{audio_index}", "file_name": f"audio{audio_index}", "duration": duration, "muted": False, "volume_db": 0.0, }, }) video_indices = segment.get("video_indices", []) if video_indices: video_index = int(video_indices[0]) video_segments.append({ "id": f"override-video-{index + 1}", "start_frame": start_frame, "end_frame": end_frame, "origin_start_frame": start_frame, "color": "var(--primary)", "content": { "media_type": "video", "source_type": "slot", "slot_name": f"video{video_index}", "file_name": f"video{video_index}", "duration": duration, "muted": False, "volume_db": 0.0, }, }) if prompt_override_has_frame_ranges(prompt_override): total_length = max(1, max_timeline_end_frame + 1) override_data = dict(base_data) override_data["total_length"] = max(total_length, max_end_frame, 1) override_data["_total_length_is_final"] = True override_data["frame_rate"] = frame_rate tracks: list[dict] = [{ "id": "override-task-track", "name": "Tasks", "type": "task", "color": "var(--multitrack-task-bg)", "muted": False, "locked": False, "segments": task_segments, }] if video_segments: tracks.append({ "id": "override-video-track", "name": "Video", "type": "video", "color": "var(--primary)", "muted": False, "solo": False, "volume_db": 0.0, "locked": False, "segments": video_segments, }) for audio_index, audio_segments in sorted(audio_segments_by_index.items()): tracks.append({ "id": f"override-audio-track-{audio_index}", "name": f"Audio {audio_index}", "type": "audio", "color": "var(--highlight)", "muted": False, "solo": False, "volume_db": 0.0, "locked": False, "segments": audio_segments, }) override_data["tracks"] = tracks return override_data def build_minimax_prompt_override_json( prompts: list[str], duration: str, generation_type: str = MINIMAX_DEFAULT_GENERATION_TYPE, continuity_mode: str = MINIMAX_DEFAULT_CONTINUITY_MODE, system_prompt: str | None = None, video_track_lock: int = 0, audio_track_lock: int = 0, ) -> str: """Serialize the ``easy minimaxPromptOverride`` node payload as JSON.""" return json.dumps( { "type": MINIMAX_PROMPT_OVERRIDE_TYPE, "version": 1, "prompts": [str(prompt) for prompt in prompts], "duration": str(duration or "10").strip() or "10", "generation_type": ( str(generation_type or MINIMAX_DEFAULT_GENERATION_TYPE).strip() or MINIMAX_DEFAULT_GENERATION_TYPE ), "continuity_mode": ( str(continuity_mode or MINIMAX_DEFAULT_CONTINUITY_MODE).strip() or MINIMAX_DEFAULT_CONTINUITY_MODE ), "system_prompt": str(system_prompt or "").strip(), "video_track_lock": int(video_track_lock or 0), "audio_track_lock": int(audio_track_lock or 0), }, ensure_ascii=False, ) def parse_minimax_prompt_override(prompt_override) -> dict | None: """Return a MiniMax prompt override dict, or ``None`` for other payloads.""" if isinstance(prompt_override, dict): data = prompt_override elif isinstance(prompt_override, str): text = prompt_override.strip() if not text: return None try: data = json.loads(text) except (TypeError, json.JSONDecodeError): return None else: return None if not isinstance(data, dict): return None if data.get("type") != MINIMAX_PROMPT_OVERRIDE_TYPE: return None if not isinstance(data.get("prompts"), list): return None return data def is_minimax_prompt_override(prompt_override) -> bool: return parse_minimax_prompt_override(prompt_override) is not None def _parse_minimax_durations(value, count: int) -> list[float]: if count <= 0: return [] text = "10" if value is None else str(value).strip() if not text: text = "10" raw_parts = [part.strip() for part in text.split(",") if part.strip()] if not raw_parts: raise ValueError("MiniMax duration must contain at least one value.") seconds: list[float] = [] for part in raw_parts: try: second = float(part) except (TypeError, ValueError) as error: raise ValueError( f"Invalid MiniMax duration value: {part!r}." ) from error if not math.isfinite(second) or not 2 <= second <= 15: raise ValueError( "MiniMax duration values must be between 2 and 15 seconds." ) seconds.append(second) return [ seconds[min(index, len(seconds) - 1)] for index in range(count) ] def _parse_minimax_multi_value( value, count: int, *, default: str, allowed: set[str], field_name: str, ) -> list[str]: """Parse a comma-separated per-segment MiniMax value, reusing the tail.""" if count <= 0: return [] text = default if value is None else str(value).strip() if not text: text = default raw_parts = [part.strip() for part in text.split(",") if part.strip()] if not raw_parts: raise ValueError(f"MiniMax {field_name} must contain at least one value.") values: list[str] = [] for part in raw_parts: normalized = part.lower() if normalized not in allowed: raise ValueError( f"MiniMax {field_name} value {part!r} is not one of " f"{sorted(allowed)!r}." ) values.append(normalized) return [values[min(index, len(values) - 1)] for index in range(count)] def _parse_minimax_generation_types(value, count: int) -> list[str]: return _parse_minimax_multi_value( value, count, default=MINIMAX_DEFAULT_GENERATION_TYPE, allowed=MINIMAX_GENERATION_TYPES, field_name="generation_type", ) def _parse_minimax_continuity_modes(value, count: int) -> list[str]: return _parse_minimax_multi_value( value, count, default=MINIMAX_DEFAULT_CONTINUITY_MODE, allowed=MINIMAX_CONTINUITY_MODES, field_name="continuity_mode", ) def _minimax_task_mode_for_generation_type(generation_type: str) -> str: if generation_type == "r2v": return "ref" if generation_type == "l2v": return "l2v" return "default" def _normalize_minimax_prompts( prompts: list[str], ) -> tuple[list[str], list[dict[str, list[int]]]]: """Normalize @-style and