Datasets:
Download scripts/validator.py from joemaddalone/ffmpeg-nl2cmd-clean: direct link, hf CLI and curl.
- Browser
- Download file 15.1 kB
-
https://huggingface.co/datasets/joemaddalone/ffmpeg-nl2cmd-clean/resolve/main/scripts/validator.py
- Command line
-
hf download hf://datasets/joemaddalone/ffmpeg-nl2cmd-clean/scripts/validator.py
-
curl -L -o validator.py https://huggingface.co/datasets/joemaddalone/ffmpeg-nl2cmd-clean/resolve/main/scripts/validator.py
15.1 kB
| #!/usr/bin/env python3 | |
| """Shared ffmpeg command validator: synthetic media, execution, static checks, metrics. | |
| Used by the audit, the baselines and the fine-tuned eval so every number comes | |
| from the same code path. Requires ffmpeg on PATH. | |
| """ | |
| import os | |
| import re | |
| import shlex | |
| import shutil | |
| import subprocess | |
| import tempfile | |
| VIDEO_EXT = {".mp4", ".mkv", ".avi", ".mov", ".webm", ".flv", ".m4v", ".mpg", ".mpeg", ".ts", ".wmv", ".3gp"} | |
| AUDIO_EXT = {".wav", ".mp3", ".m4a", ".aac", ".flac", ".ogg", ".opus", ".wma", ".aiff", ".amr"} | |
| IMAGE_EXT = {".png", ".jpg", ".jpeg", ".bmp", ".webp", ".tiff", ".tif", ".ppm", ".pgm", ".pam"} | |
| SUB_EXT = {".srt", ".ass", ".ssa", ".vtt", ".ttml"} | |
| LAVFI_SOURCES = {"testsrc", "testsrc2", "sine", "color", "anullsrc", "mandelbrot", | |
| "smptebars", "smptehdbars", "rgbtestsrc", "life", "cellauto", "haldclutsrc", | |
| "nullsrc", "gradients", "qrencodesrc", "zeroes", "srtpacketsrc", "vignette", | |
| "aevalsrc", "avectorscope", "showwaves", "showwavespic", "showspectrum", "showcqt"} | |
| STATIC_ONLY_MARKERS = [ | |
| "nvenc", "qsv", "v4l2", "rtsp", "srt:", "udp:", "rtp:", "videotoolbox", "vaapi", | |
| "d3d11va", "dxva2", "mediacodec", "cuda", "cuvid", "mmal", "omx", | |
| "dshow", "avfoundation", "x11grab", "gdigrab", ":video=", ":audio=", | |
| ] | |
| HEAVY = ("minterpolate", "loop=loop=-1", "framerate=240", "fps=240") | |
| _cap_cache = {} | |
| def _run(cmd, timeout): | |
| return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout) | |
| def capabilities(): | |
| """Cached sets of real ffmpeg filters, encoders and muxers.""" | |
| if "filters" not in _cap_cache: | |
| filt = _run(["ffmpeg", "-hide_banner", "-filters"], 15).stdout.decode(errors="replace") | |
| _cap_cache["filters"] = set(re.findall(r"^ [A-Z0-9\.]+\s+(\w+)", filt, re.M)) | |
| if "encoders" not in _cap_cache: | |
| enc = _run(["ffmpeg", "-hide_banner", "-encoders"], 15).stdout.decode(errors="replace") | |
| _cap_cache["encoders"] = set(re.findall(r"^ [AVS\.]{6}\s+(\S+)", enc, re.M)) | |
| if "muxers" not in _cap_cache: | |
| mux = _run(["ffmpeg", "-hide_banner", "-muxers"], 15).stdout.decode(errors="replace") | |
| _cap_cache["muxers"] = set(re.findall(r"^ [A-Z0-9\.]+\s+(\w+)", mux, re.M)) | |
| return _cap_cache | |
| def ext_of(fn): | |
| m = re.search(r"\.([A-Za-z0-9]{1,6})$", fn) | |
| return ("." + m.group(1).lower()) if m else "" | |
| def is_sequence(fn): | |
| return bool(re.search(r"%0?\d*d", fn)) | |
| def is_glob(fn): | |
| return bool(re.search(r"[\*\?]", fn)) | |
| def seq_dir(fn): | |
| return os.path.dirname(fn) or "." | |
| def is_lavfi_source(tok): | |
| return tok.split("=")[0].split(":")[0] in LAVFI_SOURCES | |
| def command_inputs(cmd): | |
| """Positional inputs + filenames embedded in filter args.""" | |
| try: | |
| toks = shlex.split(cmd) | |
| except ValueError: | |
| return [] | |
| ins, i = [], 1 | |
| while i < len(toks): | |
| t = toks[i] | |
| if t == "-i" and i + 1 < len(toks): | |
| ins.append(toks[i + 1]) | |
| i += 2 | |
| continue | |
| i += 1 | |
| files = [] | |
| for m in re.finditer(r"(?:subtitles|ass)=([^:'\"\s]+\.(?:srt|ass|ssa|vtt))|" | |
| r"(?:textfile|fontfile|filename)=([\w./\-]+\.\w+)", cmd): | |
| files.append(m.group(1) or m.group(2)) | |
| out = [] | |
| for fn in ins + files: | |
| if not fn or fn.startswith("-") or is_lavfi_source(fn) or ":" in fn: | |
| continue | |
| if "." not in fn and "%" not in fn and "*" not in fn and "/" not in fn: | |
| continue | |
| if fn not in out: | |
| out.append(fn) | |
| return out | |
| def make_input_file(path, is_concat=False): | |
| """Create a tiny synthetic media file at `path` based on its extension.""" | |
| os.makedirs(os.path.dirname(path) or ".", exist_ok=True) | |
| ext = ext_of(path) | |
| try: | |
| if ext == ".txt" and is_concat: | |
| with open(path, "w") as f: | |
| f.write("file 'video.mp4'\n") | |
| return os.path.exists(path) | |
| if is_glob(path): | |
| d = seq_dir(path) | |
| os.makedirs(d, exist_ok=True) | |
| e = ext_of(path) or ".jpg" | |
| for k in range(1, 4): | |
| _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", | |
| "-i", "testsrc=size=64x64:rate=1", "-frames:v", "1", | |
| os.path.join(d, f"synthimg_{k:03d}{e}")], 15) | |
| return len(os.listdir(d)) >= 3 | |
| if ext in SUB_EXT or ext == ".txt": | |
| with open(path, "w") as f: | |
| f.write("1\n00:00:00,000 --> 00:00:00,500\nhello world\n\nsample text\n") | |
| return os.path.exists(path) | |
| if is_sequence(path) or ext in IMAGE_EXT: | |
| args = ["ffmpeg", "-v", "error", "-y", "-f", "lavfi", | |
| "-i", "testsrc=duration=0.5:size=64x64:rate=5"] | |
| if is_sequence(path): | |
| args.append(path) | |
| else: | |
| args += ["-frames:v", "1", path] | |
| _run(args, 15) | |
| if is_sequence(path): | |
| import glob as _g | |
| base = re.sub(r"%0?\d*d", "*", os.path.basename(path)) | |
| return len(_g.glob(os.path.join(seq_dir(path), base))) >= 1 | |
| return os.path.exists(path) | |
| if ext in (".mpg", ".mpeg"): | |
| _run(["ffmpeg", "-v", "error", "-y", | |
| "-f", "lavfi", "-i", "testsrc=duration=12:size=640x480:rate=10", | |
| "-f", "lavfi", "-i", "sine=duration=12", | |
| "-map", "0:v", "-map", "1:a", "-c:v", "mpeg2video", "-c:a", "mp2", | |
| "-pix_fmt", "yuvj420p", path], 60) | |
| return os.path.exists(path) | |
| if ext == ".opus": | |
| _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=3", | |
| "-c:a", "libopus", path], 30) | |
| return os.path.exists(path) | |
| if ext in AUDIO_EXT: | |
| _run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", | |
| "-i", "sine=duration=12:frequency=440", "-ar", "44100", "-ac", "1", path], 30) | |
| return os.path.exists(path) | |
| if ext in VIDEO_EXT or ext == "": | |
| sub_fmt = {".mp4": "mov_text", ".m4v": "mov_text", ".mov": "mov_text", | |
| ".mkv": "srt", ".webm": "webvtt"}.get(ext) | |
| srt = os.path.join(os.path.dirname(path) or ".", "_synth.srt") | |
| with open(srt, "w") as f: | |
| f.write("1\n00:00:00,000 --> 00:00:11,500\nhello world\n\n2\n" | |
| "00:00:05,000 --> 00:00:11,500\nsecond line\n\n") | |
| args = ["ffmpeg", "-v", "error", "-y", | |
| "-f", "lavfi", "-i", "testsrc=duration=12:size=640x480:rate=10", | |
| "-f", "lavfi", "-i", "sine=duration=12:frequency=440"] | |
| maps = ["-map", "0:v", "-map", "1:a"] | |
| if sub_fmt: | |
| args += ["-i", srt] | |
| maps += ["-map", "2:s", "-c:s", sub_fmt] | |
| args += maps + ["-pix_fmt", "yuvj420p", "-shortest", path] | |
| _run(args, 60) | |
| return os.path.exists(path) | |
| return False | |
| except Exception: | |
| return False | |
| class MediaPool: | |
| """Creates synthetic inputs on demand, keyed by referenced filename.""" | |
| def __init__(self, base_dir): | |
| self.base = base_dir | |
| self.made = {} | |
| def get(self, fn, is_concat=False): | |
| if fn in self.made: | |
| return self.made[fn] | |
| if is_glob(fn) or is_sequence(fn): | |
| path = os.path.join(self.base, "_pat", os.path.basename(fn)) | |
| else: | |
| path = os.path.join(self.base, re.sub(r"[^\w.\-]", "_", fn)) | |
| ok = make_input_file(path, is_concat=is_concat) | |
| self.made[fn] = path if ok else None | |
| return self.made[fn] | |
| def is_static_only(cmd): | |
| text = cmd | |
| if any(m in text for m in STATIC_ONLY_MARKERS): | |
| return True | |
| try: | |
| toks = shlex.split(cmd) | |
| except ValueError: | |
| return False | |
| return any(not t.startswith("-") and t.split("=")[0].split(":")[0] in LAVFI_SOURCES | |
| for t in toks) and any(t == "-f" and i + 1 < len(toks) and toks[i + 1] == "lavfi" | |
| for i, t in enumerate(toks)) and False | |
| def static_validate(cmd): | |
| """Problems that mean the command cannot work on any ffmpeg build (empty = OK).""" | |
| caps = capabilities() | |
| problems = [] | |
| for m in re.finditer(r"-v(?:f)?\s+(?:(['\"])(.*?)\1|(\S+))|-af\s+(?:(['\"])(.*?)\4|(\S+))|" | |
| r"-filter_complex\s+(?:(['\"])(.*?)\7|(\S+))", cmd): | |
| chain = next((g for g in m.groups() if g), "") | |
| for part in re.split(r"[,;]", chain): | |
| n = part.strip().split("=")[0].split("[")[0].strip() | |
| if n and re.fullmatch(r"[a-z0-9_]+", n) and n not in caps["filters"]: | |
| problems.append(f"filter not found: {n}") | |
| for m in re.finditer(r"(?:-c:v|-c:a|-vcodec|-acodec)\s+(\S+)", cmd): | |
| enc = m.group(1) | |
| if enc not in ("copy", "none") and enc not in caps["encoders"]: | |
| problems.append(f"encoder not found: {enc}") | |
| return problems | |
| def run_command(cmd, pool, timeout=12): | |
| """Run the command verbatim in a temp dir with synthetic inputs. Returns dict.""" | |
| static_only = any(m in cmd for m in STATIC_ONLY_MARKERS) | |
| inputs = command_inputs(cmd) | |
| if static_only: | |
| probs = static_validate(cmd) | |
| return {"mode": "static", "ok": not probs, "reason": "; ".join(probs) or "static checks passed"} | |
| with tempfile.TemporaryDirectory(dir="/tmp") as td: | |
| try: | |
| missing = [] | |
| for fn in inputs: | |
| is_concat = "-f concat" in cmd and ext_of(fn) == ".txt" | |
| src = pool.get(fn, is_concat=is_concat) | |
| if src is None: | |
| missing.append(fn) | |
| continue | |
| if is_sequence(fn) or is_glob(fn): | |
| d = seq_dir(fn) | |
| os.makedirs(os.path.join(td, d), exist_ok=True) | |
| for f in os.listdir(os.path.dirname(src)): | |
| shutil.copy(os.path.join(os.path.dirname(src), f), | |
| os.path.join(td, d, os.path.basename(f))) | |
| else: | |
| dst = os.path.join(td, os.path.basename(fn)) | |
| if os.path.abspath(src) != os.path.abspath(dst): | |
| shutil.copy(src, dst) | |
| if missing: | |
| probs = static_validate(cmd) | |
| if probs: | |
| return {"mode": "static", "ok": False, "reason": "static: " + "; ".join(probs)} | |
| return {"mode": "static", "ok": True, | |
| "reason": "input not creatable: " + ",".join(missing[:3])} | |
| p = _run(["/bin/sh", "-lc", f"cd {td} && timeout {timeout} {cmd}"], timeout + 4) | |
| err = p.stderr.decode(errors="replace").strip().splitlines() | |
| if p.returncode == 0: | |
| return {"mode": "run", "ok": True, "reason": ""} | |
| reason = err[-1] if err else f"exit {p.returncode}" | |
| if p.returncode == 124 or "timeout" in reason.lower(): | |
| if any(h in cmd for h in HEAVY): | |
| probs = static_validate(cmd) | |
| return {"mode": "static", "ok": not probs, | |
| "reason": "heavy filter: " + ("; ".join(probs) or "static checks passed")} | |
| return {"mode": "run", "ok": False, "reason": "timeout"} | |
| return {"mode": "run", "ok": False, "reason": reason[:300]} | |
| except Exception as e: | |
| return {"mode": "run", "ok": False, "reason": f"harness error: {e}"} | |
| # ---------------------------------------------------------------- metrics | |
| def normalize_cmd(s): | |
| s = s.strip().lower() | |
| s = s.replace('"', "'").replace("`", "") | |
| s = re.sub(r"\s+", " ", s) | |
| s = re.sub(r"\s*=\s*", "=", s) | |
| return s.strip() | |
| def token_f1(ref, pred): | |
| r, p = ref.split(), pred.split() | |
| common = {} | |
| for t in r: | |
| common[t] = max(common.get(t, 0), p.count(t)) | |
| tp = sum(min(r.count(t), p.count(t)) for t in set(r)) | |
| prec = tp / len(p) if p else 0.0 | |
| rec = tp / len(r) if r else 0.0 | |
| return 2 * prec * rec / (prec + rec) if (prec + rec) else 0.0 | |
| def extract_filters(cmd): | |
| out = set() | |
| for m in re.finditer(r"-v(?:f)?\s+(?:(['\"])(.*?)\1|(\S+))|-af\s+(?:(['\"])(.*?)\4|(\S+))|" | |
| r"-filter_complex\s+(?:(['\"])(.*?)\7|(\S+))", cmd): | |
| chain = next((g for g in m.groups() if g), "") | |
| for part in re.split(r"[,;]", chain): | |
| n = part.strip().split("=")[0].split("[")[0].strip() | |
| if n and re.fullmatch(r"[a-z0-9_]+", n): | |
| out.add(n) | |
| return out | |
| def extract_flags(cmd): | |
| try: | |
| toks = shlex.split(cmd) | |
| except ValueError: | |
| return set() | |
| return {t.split("=")[0] for t in toks if t.startswith("-") and len(t) > 1 | |
| and not re.fullmatch(r"-[\d.]+", t)} | |
| # core options that ffmpeg 7.x -h full does not list but always accept | |
| CORE_OPTS = { | |
| "i", "f", "map", "map_chapters", "c", "c:v", "c:a", "c:s", "vf", "af", | |
| "filter_complex", "ss", "to", "t", "b", "b:v", "b:a", "ar", "ac", "vn", "an", | |
| "sn", "dn", "y", "n", "pix_fmt", "r", "s", "shortest", "vcodec", "acodec", | |
| "scodec", "frames", "q", "crf", "preset", "profile", "level", "metadata", | |
| "aspect", "hwaccel", "itsoffset", "loop", "update", "nostdin", "hide_banner", | |
| "v", "stats", "filter_threads", "max_muxing_queue_size", "movflags", | |
| "hls_time", "hls_playlist_type", "hls_segment_filename", "segment_time", | |
| "map_metadata", "map_channel", "vol", "sample_fmt", "channel_layout", "rc", | |
| } | |
| def hallucinated_items(cmd): | |
| """Flags/filters in cmd that do not exist in this ffmpeg build.""" | |
| caps = capabilities() | |
| bad = [] | |
| for f in extract_filters(cmd): | |
| if f not in caps["filters"]: | |
| bad.append(f"filter:{f}") | |
| for fl in extract_flags(cmd): | |
| base = fl.lstrip("-") | |
| if base not in _cap_cache.get("options", set()) and base not in CORE_OPTS: | |
| bad.append(f"flag:{fl}") | |
| return bad | |
| def load_options(): | |
| opts = set() | |
| p = _run(["ffmpeg", "-h", "full"], 15) | |
| for m in re.finditer(r"^\s*(-{1,2}[\w:\-]+)", p.stdout.decode(errors="replace"), re.M): | |
| opts.add(m.group(1).lstrip("-")) | |
| _cap_cache["options"] = opts | |
| return opts | |
| def format_ok(pred): | |
| if "\n" in pred.strip() or "\r" in pred.strip(): | |
| return False | |
| s = pred.strip() | |
| return bool(re.match(r"^ffmpeg(\s|$)", s)) and "```" not in s and len(s) > len("ffmpeg") | |
| def classify_category(cmd): | |
| text = cmd | |
| if any(m in text for m in ("rtsp", "udp:", "rtp:", "srt:", "http://", "https://", "m3u8", "-hls")): | |
| return "streaming" | |
| if "concat" in text: | |
| return "concat" | |
| if "-ss" in text or "-to" in text or re.search(r"\s-t\s", text): | |
| return "trim" | |
| try: | |
| toks = shlex.split(text) | |
| except ValueError: | |
| toks = text.split() | |
| if "-af" in toks: | |
| return "audio filter" | |
| if "-vf" in toks or "filter_complex" in text: | |
| return "video filter" | |
| return "conversion" | |