Datasets:

nvidia
/

VESPER

# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: LicenseRef-NVIDIA-OneWay-Noncommercial

"""OpenAI-compatible chat-completions client for the evaluated models and the judge.
A clip is sent in one of two ways:
* ``gemini_video``: the whole clip as one ``image_url`` part holding a
  ``data:video/mp4;base64,...`` URL.
* ``openai_frames``: JPEG frames spread evenly across the clip, one
  ``image_url`` part each.
"""
from __future__ import annotations

import base64
import importlib.util
import json
import os
import socket
import sys
import time
import urllib.error
import urllib.request

CHAT_COMPLETIONS_URL = (os.environ.get("VLM_API_BASE", "").rstrip("/") + "/v1/chat/completions") if os.environ.get("VLM_API_BASE", "") else ""

# HTTP statuses worth retrying: server errors, gateway failures and rate limits.
# A failed request is dropped from the run, so transient errors must be retried.
RETRYABLE_STATUS = frozenset({429, 500, 502, 503, 504})

# Socket timeout for every chat-completions POST. Without one, urlopen can block
# forever on a dead connection.
HTTP_TIMEOUT_SEC = float(os.environ.get("VLM_HTTP_TIMEOUT_SEC", "600"))

# Attempts per request to an evaluated model (retryable errors only), and the
# wait between attempts.
API_MAX_ATTEMPTS = 10
API_RETRY_WAIT_SEC = 5


def post_chat_completion(
    url: str,
    api_key: str,
    payload: dict,
    server_error_max_attempts: int,
    server_error_wait_sec: int,
) -> dict:
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    data = json.dumps(payload).encode("utf-8")
    attempts = max(1, server_error_max_attempts)
    for attempt in range(1, attempts + 1):
        req = urllib.request.Request(url, data=data, headers=headers, method="POST")
        body = ""
        try:
            with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SEC) as resp:
                if resp.status < 200 or resp.status >= 300:
                    print(f"Request failed with HTTP {resp.status}: {url}", file=sys.stderr)
                    sys.exit(1)
                body = resp.read().decode("utf-8")
        except urllib.error.HTTPError as e:
            err_body = e.read().decode("utf-8", errors="replace")
            if e.code in RETRYABLE_STATUS and attempt < attempts:
                print(
                    f"HTTP {e.code} on POST {url} "
                    f"(attempt {attempt}/{attempts}), retrying in {server_error_wait_sec}s...",
                    file=sys.stderr,
                )
                time.sleep(server_error_wait_sec)
                continue
            print(f"Request failed with HTTP {e.code}: {url}", file=sys.stderr)
            if err_body:
                print(err_body[:2000], file=sys.stderr)
            sys.exit(1)
        except (TimeoutError, socket.timeout, urllib.error.URLError) as e:
            # MUST stay below the HTTPError clause: HTTPError subclasses URLError,
            # so ordering it first would swallow every HTTP status here.
            # A stalled connection is retried exactly like a 5xx.
            if attempt < attempts:
                print(
                    f"{type(e).__name__} on POST {url} "
                    f"(attempt {attempt}/{attempts}), retrying in {server_error_wait_sec}s...",
                    file=sys.stderr,
                )
                time.sleep(server_error_wait_sec)
                continue
            print(
                f"Request failed after {attempts} attempts ({type(e).__name__}): {url}",
                file=sys.stderr,
            )
            sys.exit(1)

        if not body:
            return {}
        return json.loads(body)
    sys.exit(1)


def video_mime_from_path(path: str) -> str:
    lower = path.lower()
    if lower.endswith(".mp4"):
        return "video/mp4"
    if lower.endswith(".webm"):
        return "video/webm"
    if lower.endswith(".mov"):
        return "video/quicktime"
    if lower.endswith(".mpeg") or lower.endswith(".mpg"):
        return "video/mpeg"
    print(
        "Unsupported video extension (use .mp4, .webm, .mov, .mpeg, .mpg): "
        f"{path}",
        file=sys.stderr,
    )
    sys.exit(1)


def video_data_uri_from_file(video_path: str) -> str:
    p = video_path if os.path.isabs(video_path) else os.path.abspath(video_path)
    if not os.path.isfile(p):
        print(f"Video file not found: {p}", file=sys.stderr)
        sys.exit(1)
    with open(p, "rb") as f:
        raw = f.read()
    if not raw:
        print(f"Video file is empty: {p}", file=sys.stderr)
        sys.exit(1)
    b64 = base64.standard_b64encode(raw).decode("ascii")
    return f"data:{video_mime_from_path(p)};base64,{b64}"


def build_messages_gemini_video(question: str, video_data_uri: str) -> list[dict]:
    """Question text plus one image_url part holding the whole clip."""
    return [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": question},
                {
                    "type": "image_url",
                    "image_url": {"url": video_data_uri},
                },
            ],
        }
    ]


def load_cv2():
    if importlib.util.find_spec("cv2") is None:
        print(
            "Frame mode needs OpenCV: pip install opencv-python-headless",
            file=sys.stderr,
        )
        sys.exit(1)
    import cv2

    return cv2


def extract_jpeg_base64_frames(video_path: str, max_frames: int) -> list[str]:
    """Return up to ``max_frames`` JPEG frames spread evenly from the first to the last frame."""
    cv2 = load_cv2()
    cap = cv2.VideoCapture(video_path)
    if not cap.isOpened():
        print(f"Cannot open video for frame extraction: {video_path}", file=sys.stderr)
        sys.exit(1)
    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
    out: list[str] = []
    if total <= 0:
        # Frame count unavailable: decode everything, then subsample evenly.
        frames = []
        while True:
            ok, fr = cap.read()
            if not ok:
                break
            frames.append(fr)
        cap.release()
        if not frames:
            return out
        n = min(max_frames, len(frames))
        idxs = [round(i * (len(frames) - 1) / max(1, n - 1)) for i in range(n)] if n > 1 else [0]
        for i in idxs:
            ok, buf = cv2.imencode(".jpg", frames[i])
            if ok:
                out.append(base64.standard_b64encode(buf.tobytes()).decode("ascii"))
        return out

    n = min(max_frames, total)
    idxs = [round(i * (total - 1) / max(1, n - 1)) for i in range(n)] if n > 1 else [0]
    for i in idxs:
        cap.set(cv2.CAP_PROP_POS_FRAMES, i)
        ok, fr = cap.read()
        if not ok:
            continue
        enc_ok, buf = cv2.imencode(".jpg", fr)
        if enc_ok:
            out.append(base64.standard_b64encode(buf.tobytes()).decode("ascii"))
    cap.release()
    return out


def build_messages_openai_frames(question: str, jpeg_base64_frames: list[str]) -> list[dict]:
    """Question text plus one data:image/jpeg;base64,... part per frame."""
    parts: list[dict] = [{"type": "text", "text": question}]
    for b64 in jpeg_base64_frames:
        parts.append(
            {
                "type": "image_url",
                "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
            }
        )
    return [{"role": "user", "content": parts}]


def resolve_input_mode(flag: str, model: str) -> str:
    """``auto`` sends frames to GPT models and the whole clip to every other model."""
    if flag in ("openai_frames", "gemini_video"):
        return flag
    m = (model or "").lower()
    if "gpt-" in m or "/gpt" in m:
        return "openai_frames"
    return "gemini_video"


def extract_assistant_text(response: dict) -> str:
    choices = response.get("choices")
    if not isinstance(choices, list) or not choices:
        return ""
    ch0 = choices[0]
    if not isinstance(ch0, dict):
        return ""
    msg = ch0.get("message")
    if not isinstance(msg, dict):
        return ""
    content = msg.get("content")
    if isinstance(content, str):
        return content.strip()
    if isinstance(content, list):
        parts: list[str] = []
        for part in content:
            if not isinstance(part, dict):
                continue
            if part.get("type") == "text":
                t = (part.get("text") or "").strip()
                if t:
                    parts.append(t)
        return "\n".join(parts).strip()
    return ""


def query_model(
    video_path: str,
    question: str,
    model: str,
    api_url: str,
    api_key: str,
    input_mode: str,
    max_frames: int,
    robot_type: str = "",
) -> str:
    """Send the clip and question to a model and return its answer text."""
    if resolve_input_mode(input_mode, model) == "openai_frames":
        messages = build_messages_openai_frames(
            question, extract_jpeg_base64_frames(video_path, max_frames),
        )
    else:
        messages = build_messages_gemini_video(question, video_data_uri_from_file(video_path))

    if robot_type:
        messages = [
            {"role": "system", "content": f"You are a {robot_type}."},
            *messages,
        ]
    payload = {"model": model, "messages": messages}
    response = post_chat_completion(
        api_url, api_key, payload, API_MAX_ATTEMPTS, API_RETRY_WAIT_SEC,
    )
    return extract_assistant_text(response)

	# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
	# SPDX-License-Identifier: LicenseRef-NVIDIA-OneWay-Noncommercial

	"""OpenAI-compatible chat-completions client for the evaluated models and the judge.

	A clip is sent in one of two ways:

	* ``gemini_video``: the whole clip as one ``image_url`` part holding a
	``data:video/mp4;base64,...`` URL.
	* ``openai_frames``: JPEG frames spread evenly across the clip, one
	``image_url`` part each.
	"""
	from __future__ import annotations

	import base64
	import importlib.util
	import json
	import os
	import socket
	import sys
	import time
	import urllib.error
	import urllib.request

	CHAT_COMPLETIONS_URL = (os.environ.get("VLM_API_BASE", "").rstrip("/") + "/v1/chat/completions") if os.environ.get("VLM_API_BASE", "") else ""

	# HTTP statuses worth retrying: server errors, gateway failures and rate limits.
	# A failed request is dropped from the run, so transient errors must be retried.
	RETRYABLE_STATUS = frozenset({429, 500, 502, 503, 504})

	# Socket timeout for every chat-completions POST. Without one, urlopen can block
	# forever on a dead connection.
	HTTP_TIMEOUT_SEC = float(os.environ.get("VLM_HTTP_TIMEOUT_SEC", "600"))

	# Attempts per request to an evaluated model (retryable errors only), and the
	# wait between attempts.
	API_MAX_ATTEMPTS = 10
	API_RETRY_WAIT_SEC = 5


	def post_chat_completion(
	url: str,
	api_key: str,
	payload: dict,
	server_error_max_attempts: int,
	server_error_wait_sec: int,
	) -> dict:
	headers = {
	"Authorization": f"Bearer {api_key}",
	"Content-Type": "application/json",
	}
	data = json.dumps(payload).encode("utf-8")
	attempts = max(1, server_error_max_attempts)
	for attempt in range(1, attempts + 1):
	req = urllib.request.Request(url, data=data, headers=headers, method="POST")
	body = ""
	try:
	with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SEC) as resp:
	if resp.status < 200 or resp.status >= 300:
	print(f"Request failed with HTTP {resp.status}: {url}", file=sys.stderr)
	sys.exit(1)
	body = resp.read().decode("utf-8")
	except urllib.error.HTTPError as e:
	err_body = e.read().decode("utf-8", errors="replace")
	if e.code in RETRYABLE_STATUS and attempt < attempts:
	print(
	f"HTTP {e.code} on POST {url} "
	f"(attempt {attempt}/{attempts}), retrying in {server_error_wait_sec}s...",
	file=sys.stderr,
	)
	time.sleep(server_error_wait_sec)
	continue
	print(f"Request failed with HTTP {e.code}: {url}", file=sys.stderr)
	if err_body:
	print(err_body[:2000], file=sys.stderr)
	sys.exit(1)
	except (TimeoutError, socket.timeout, urllib.error.URLError) as e:
	# MUST stay below the HTTPError clause: HTTPError subclasses URLError,
	# so ordering it first would swallow every HTTP status here.
	# A stalled connection is retried exactly like a 5xx.
	if attempt < attempts:
	print(
	f"{type(e).__name__} on POST {url} "
	f"(attempt {attempt}/{attempts}), retrying in {server_error_wait_sec}s...",
	file=sys.stderr,
	)
	time.sleep(server_error_wait_sec)
	continue
	print(
	f"Request failed after {attempts} attempts ({type(e).__name__}): {url}",
	file=sys.stderr,
	)
	sys.exit(1)

	if not body:
	return {}
	return json.loads(body)
	sys.exit(1)


	def video_mime_from_path(path: str) -> str:
	lower = path.lower()
	if lower.endswith(".mp4"):
	return "video/mp4"
	if lower.endswith(".webm"):
	return "video/webm"
	if lower.endswith(".mov"):
	return "video/quicktime"
	if lower.endswith(".mpeg") or lower.endswith(".mpg"):
	return "video/mpeg"
	print(
	"Unsupported video extension (use .mp4, .webm, .mov, .mpeg, .mpg): "
	f"{path}",
	file=sys.stderr,
	)
	sys.exit(1)


	def video_data_uri_from_file(video_path: str) -> str:
	p = video_path if os.path.isabs(video_path) else os.path.abspath(video_path)
	if not os.path.isfile(p):
	print(f"Video file not found: {p}", file=sys.stderr)
	sys.exit(1)
	with open(p, "rb") as f:
	raw = f.read()
	if not raw:
	print(f"Video file is empty: {p}", file=sys.stderr)
	sys.exit(1)
	b64 = base64.standard_b64encode(raw).decode("ascii")
	return f"data:{video_mime_from_path(p)};base64,{b64}"


	def build_messages_gemini_video(question: str, video_data_uri: str) -> list[dict]:
	"""Question text plus one image_url part holding the whole clip."""
	return [
	{
	"role": "user",
	"content": [
	{"type": "text", "text": question},
	{
	"type": "image_url",
	"image_url": {"url": video_data_uri},
	},
	],
	}
	]


	def load_cv2():
	if importlib.util.find_spec("cv2") is None:
	print(
	"Frame mode needs OpenCV: pip install opencv-python-headless",
	file=sys.stderr,
	)
	sys.exit(1)
	import cv2

	return cv2


	def extract_jpeg_base64_frames(video_path: str, max_frames: int) -> list[str]:
	"""Return up to ``max_frames`` JPEG frames spread evenly from the first to the last frame."""
	cv2 = load_cv2()
	cap = cv2.VideoCapture(video_path)
	if not cap.isOpened():
	print(f"Cannot open video for frame extraction: {video_path}", file=sys.stderr)
	sys.exit(1)
	total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
	out: list[str] = []
	if total <= 0:
	# Frame count unavailable: decode everything, then subsample evenly.
	frames = []
	while True:
	ok, fr = cap.read()
	if not ok:
	break
	frames.append(fr)
	cap.release()
	if not frames:
	return out
	n = min(max_frames, len(frames))
	idxs = [round(i * (len(frames) - 1) / max(1, n - 1)) for i in range(n)] if n > 1 else [0]
	for i in idxs:
	ok, buf = cv2.imencode(".jpg", frames[i])
	if ok:
	out.append(base64.standard_b64encode(buf.tobytes()).decode("ascii"))
	return out

	n = min(max_frames, total)
	idxs = [round(i * (total - 1) / max(1, n - 1)) for i in range(n)] if n > 1 else [0]
	for i in idxs:
	cap.set(cv2.CAP_PROP_POS_FRAMES, i)
	ok, fr = cap.read()
	if not ok:
	continue
	enc_ok, buf = cv2.imencode(".jpg", fr)
	if enc_ok:
	out.append(base64.standard_b64encode(buf.tobytes()).decode("ascii"))
	cap.release()
	return out


	def build_messages_openai_frames(question: str, jpeg_base64_frames: list[str]) -> list[dict]:
	"""Question text plus one data:image/jpeg;base64,... part per frame."""
	parts: list[dict] = [{"type": "text", "text": question}]
	for b64 in jpeg_base64_frames:
	parts.append(
	{
	"type": "image_url",
	"image_url": {"url": f"data:image/jpeg;base64,{b64}"},
	}
	)
	return [{"role": "user", "content": parts}]


	def resolve_input_mode(flag: str, model: str) -> str:
	"""``auto`` sends frames to GPT models and the whole clip to every other model."""
	if flag in ("openai_frames", "gemini_video"):
	return flag
	m = (model or "").lower()
	if "gpt-" in m or "/gpt" in m:
	return "openai_frames"
	return "gemini_video"


	def extract_assistant_text(response: dict) -> str:
	choices = response.get("choices")
	if not isinstance(choices, list) or not choices:
	return ""
	ch0 = choices[0]
	if not isinstance(ch0, dict):
	return ""
	msg = ch0.get("message")
	if not isinstance(msg, dict):
	return ""
	content = msg.get("content")
	if isinstance(content, str):
	return content.strip()
	if isinstance(content, list):
	parts: list[str] = []
	for part in content:
	if not isinstance(part, dict):
	continue
	if part.get("type") == "text":
	t = (part.get("text") or "").strip()
	if t:
	parts.append(t)
	return "\n".join(parts).strip()
	return ""


	def query_model(
	video_path: str,
	question: str,
	model: str,
	api_url: str,
	api_key: str,
	input_mode: str,
	max_frames: int,
	robot_type: str = "",
	) -> str:
	"""Send the clip and question to a model and return its answer text."""
	if resolve_input_mode(input_mode, model) == "openai_frames":
	messages = build_messages_openai_frames(
	question, extract_jpeg_base64_frames(video_path, max_frames),
	)
	else:
	messages = build_messages_gemini_video(question, video_data_uri_from_file(video_path))

	if robot_type:
	messages = [
	{"role": "system", "content": f"You are a {robot_type}."},
	*messages,
	]
	payload = {"model": model, "messages": messages}
	response = post_chat_completion(
	api_url, api_key, payload, API_MAX_ATTEMPTS, API_RETRY_WAIT_SEC,
	)
	return extract_assistant_text(response)