ffmpeg-skill 3.8.16 → 3.8.18

package/scripts/_common/wrap.py

@@ -282,16 +282,32 @@ def _slice_atom(atom: str, max_em: float) -> "List[str]":
     No dictionary, no hyphenation library: an existing hyphen is preferred as the cut (the same
     break R1 already allows), then whatever is left is cut again at exactly the widest prefix
     that still measures within `max_em`, one character at a time. The characters themselves are
-    never rewritten -- every piece concatenates back to the original atom exactly."""
-    if text_width_em(atom) <= max_em:
-        return [atom]
-    for i in range(len(atom) - 2, 0, -1):
-        # latest hyphen whose left side still fits -- keeps the left half as large as possible
-        if atom[i] in _HYPHENS and text_width_em(atom[:i + 1]) <= max_em:
-            return [atom[:i + 1]] + _slice_atom(atom[i + 1:], max_em)
+    never rewritten -- every piece concatenates back to the original atom exactly.
+
+    Iterative, and each piece measures only the prefixes up to the first that is too wide (a
+    prefix is never narrower than a shorter one): the recursive form measured every prefix of the
+    remaining atom for each piece it cut, so a 1 KB hyphenated cue took seconds and 4 KB minutes
+    (A11, #465), in caption.py's own process, which --timeout (a limit on each ffmpeg call) does
+    not bound. The pieces are the ones the recursive form cut."""
     pieces: "List[str]" = []
+    rest = atom
+    while True:
+        # latest hyphen whose left side still fits -- keeps the left half as large as possible;
+        # a rest whose every prefix fits, itself included, is the last piece
+        cut = 0
+        for end in range(1, len(rest) + 1):
+            if text_width_em(rest[:end]) > max_em:
+                break
+            if 1 <= end - 1 <= len(rest) - 2 and rest[end - 1] in _HYPHENS:
+                cut = end
+        else:
+            return pieces + [rest]
+        if not cut:
+            break
+        pieces.append(rest[:cut])
+        rest = rest[cut:]
     cur = ""
-    for ch in atom:
+    for ch in rest:
         candidate = cur + ch
         if cur and text_width_em(candidate) > max_em:
             pieces.append(cur)

package/scripts/_contract.py

@@ -436,6 +436,7 @@ ERROR_REASONS = {
     "output_is_directory": "the output path is a directory; details: {output}",
     "media_path_is_playlist": "an input is a playlist that ffmpeg would follow to the files or URLs it names: HLS .m3u8/.m3u or an ffconcat list (by name or by its first bytes), a DASH manifest or an IMF composition playlist (by name or by the content ffmpeg's own probe looks for, whatever the file is called); the skill takes media files only; details: {path}",
     "media_path_has_line_break": "a path written into a concat list (loop.py, join.py --copy, sequence.py, multi-part cuts) contains a line break, which the concat format cannot hold: each line is a directive, so the name would add entries to the list; details: {path}",
+    "still_unreadable": "an input read by an image demuxer (a .png, .jpg, ... name) has a picture stream with no frame size: the file is not an image ffmpeg can decode (a text file named .png); details: {path, format, codec}",
     "media_path_not_a_file": "an input exists but is not a regular file (a FIFO or a device), which ffmpeg would block on or read as a stream; details: {path}",
     "join_copy_mismatch": "join.py --copy: a clip's streams do not match the first clip's, it hides pre-roll frames with an edit list, or its picture and sound end more than 50 ms apart; details: {clips: [{index?, path, differs}]}",
     "output_path_taken": "two files one run writes (a side file and the output, or two side files) resolve to the same path, so the second would replace the first; details: {output, other}",
@@ -446,7 +447,7 @@ ERROR_REASONS = {
     "output_dir_not_writable": "the output's directory is not writable; details: {output, directory}",
     "output_container_codecs": "a .webm output whose command encodes video or sound WebM cannot hold (H.264/HEVC, AAC; WebM takes VP8/VP9/AV1 and Opus/Vorbis), refused before ffmpeg runs; details: {output, container, encoders}",
     "timemap_path_taken": "silence.py --timemap names the same file as -o, --edl or --plan; details: {timemap, flag, path}",
-    "output_locked": "another run holds the output's lock; details: {lock, output, pid, pid_alive, deadline, why}",
+    "output_locked": "another run holds the output's lock, or is taking a stale one over (why: takeover_in_progress), or a stale lock cannot be taken over safely because the filesystem gives no OS file lock (why: takeover_unavailable: delete it by hand); details: {lock, output, pid, pid_alive, deadline, why}",
     "plan_inputs_changed": "render.py PLAN: a fingerprinted input is missing or changed; details: {plan, plan_sha256, checked_at, "
                            "inputs: [{path, status: unchanged|changed|missing, expected: {size, sha256_head_tail}, actual: {size, "
                            "sha256_head_tail} | \"missing\"}], unbound_inputs, audit_log}",
@@ -1943,6 +1944,11 @@ MCP_PROMPTS: List[Dict[str, Any]] = [
                      "to keep HDR and only drop the Dolby Vision layer, when strip_dovi is asked for). A flat, washed-out "
                      "look after a re-encode usually means HDR metadata was lost upstream; `probe` shows `hdr: true` "
                      "only for a real PQ/HLG/Dolby Vision signal, and `bt2020_or_hdr: true` also for BT.2020 SDR."),
+        # A23 (#465): strip_dovi was taken and changed nothing; true now asks for the other recipe
+        "flags": {"strip_dovi": (
+            "Keep {input} HDR and drop only its Dolby Vision layer: `color.py {input} --strip-dovi`, a stream copy "
+            "(HEVC only) that removes the Dolby Vision RPU so players use the HLG/HDR10 base layer. A source with no "
+            "Dolby Vision metadata gets a `dovi_not_detected` warning.")},
     },
 ]
 
@@ -1968,7 +1974,17 @@ def mcp_prompt_get(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
     fields: Dict[str, str] = {a["name"]: str((arguments or {}).get(a["name"]) or a.get("default", "")) for a in prompt["arguments"]}
     for opt_name, clause in prompt["optional"].items():
         fields[opt_name] = clause.format(**fields) if fields.get(opt_name) else ""
-    text = prompt["template"].format(**fields)
+    template = prompt["template"]
+    for flag, flag_template in (prompt.get("flags") or {}).items():
+        # a yes/no argument picks the recipe; every prompt argument arrives as a string, so
+        # "false" is no, and a value that is neither is a caller mistake (ValueError, as above)
+        value = (arguments or {}).get(flag)
+        word = str(value).strip().lower() if value is not None else ""
+        if word in ("true", "1", "yes"):
+            template = flag_template
+        elif word not in ("", "false", "0", "no"):
+            raise ValueError(f"prompt {name!r}: {flag} must be true or false, got {value!r}")
+    text = template.format(**fields)
     return {"description": prompt["description"], "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}
 
 

package/scripts/batch.py

@@ -699,10 +699,15 @@ def main() -> int:
     created = [d for d in (outdir, work) if not d.exists()]
     outdir.mkdir(parents=True, exist_ok=True)
     work.mkdir(parents=True, exist_ok=True)
-    if STATE.dry_run and created:
+    # a real run that is refused before any item starts (--jobs, an output collision, a final path
+    # that is an input) leaves nothing behind either (A187, #465: it left out/ and out/.work)
+    item_started = {"item": False}
+    if created:
         import atexit
 
         def _remove_empty_dirs() -> None:
+            if not STATE.dry_run and item_started["item"]:
+                return
             for d in sorted(created, key=lambda p: len(str(p)), reverse=True):
                 try:
                     if not any(d.iterdir()):
@@ -850,6 +855,7 @@ def main() -> int:
         def run_item(i: int, src: Path) -> Dict[str, Any]:
             """process() in the item's own work directory, which goes when it ends, however it ends."""
             import shutil
+            item_started["item"] = True
             iw = item_work(i, src)
             try:
                 return process(src, recipe, outdir, iw, deadline)

package/scripts/broll.py

@@ -26,7 +26,7 @@ from _common.decision import (av_trim, conform_output_t, conform_to_length, fram
                               grid_at_or_after, silence_filter, stream_starts, window_expr, windowed_overlay_x)
 from _common import STATE, add_common, aac_args, apply_common, cfr_args, cfr_at_input, as_limited, default_output, die, draws_chroma, drawn_chain, emit, ffmpeg_base, info, time_arg, label_chain, matrix_chain, overlay_format, range_chain, probe, run, validate_color, video_args, X264_PRESETS, fmt_secs
 from _common.emit import note, record_fallback
-from _common.probe import display_size, square_pixels, square_pixels_note
+from _common.probe import display_size, is_still_input, square_pixels, square_pixels_note, still_loop_args
 from _common.emit import input_length
 
 
@@ -109,7 +109,9 @@ def main() -> int:
             die(f"cutaway {i + 1}: --at {at:g}s is past the end of the A-roll ({dur_a:.3f}s)")
         if dur_a and at + length > dur_a + 0.01:
             die(f"cutaway {i + 1}: {at:g}s + {length:g}s runs past the end of the A-roll ({dur_a:.3f}s)")
-        dur_b = input_length(meta_b)
+        # a still has no material to run out of: it is looped for the window. image2 gives some (a
+        # TGA) a duration of one frame, which this refused as "only -0.460s from 0.5s" (review of #532)
+        dur_b = None if is_still_input(meta_b) else input_length(meta_b)
         if dur_b and start_b + length > dur_b + 0.01 and not STATE.dry_run:
             die(f"cutaway {i + 1}: {path} has only {dur_b - start_b:.3f}s from {start_b:g}s, {length:g}s asked for")
         # the cutaway in whole frames: `first` is B's first frame at or after --from, `on` the
@@ -139,6 +141,15 @@ def main() -> int:
     output = args.output or default_output(args.input, "broll")
     cmd = ffmpeg_base() + ["-i", args.input]
     for c in cutaways:
+        # a still B-roll is one frame to a plain -i: it showed for one frame of the cutaway and A
+        # came back under it (#510). Looped, it lasts the window it is trimmed to. The bound is past
+        # the trim's end, which runs from B's first frame at or after --from on the loop's own
+        # grid for the window's whole frames: --from + --duration cut that frame off a short window
+        # (--from 0.041 --duration 0.033 needs the frame at 0.08, review of #532). A frame of B
+        # past it costs nothing: the trim drops it.
+        if is_still_input(c["meta"]):
+            frame_b = 1 / c["rate"] if c["rate"] else 0.04
+            cmd += still_loop_args(c["path"], max(c["from"], c["first"]) + max(c["length"], c["span"] or 0) + 2 * frame_b)
         cmd += ["-i", c["path"]]
 
     # Picture: each B window is trimmed, normalised to A's frame and fps, shifted to start at its

package/scripts/caption.py

@@ -55,8 +55,8 @@ from _common import asr as _asr
 from _common.asr import ENGINE_CHOICES
 from _common.emit import warn
 from _common.probe import display_size, square_pixels, square_pixels_note
-from _common.runner import carried_stream_maps, subtitle_codec_for, subtitle_container_holds
-from _common.fonts import font_choice, record_font_choice
+from _common.runner import carried_stream_maps, refuse_output_is_input, same_file, subtitle_codec_for, subtitle_container_holds
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common import (ASR_INSTALL_HINT, die_no_engine, parse_srt, transcribe, whisper_word_timings,
                      write_srt)
 from _common.asr import srt_blocks
@@ -1327,6 +1327,11 @@ def main() -> int:
     if args.brand and bcap.get("karaoke") and not args.karaoke:
         args.karaoke = True
     if args.brand and brand.get("font_file") and not args.fonts_dir:
+        # the brand's face is found in its directory by libass, so a file there that is no font
+        # left libass to another face without a word (#510); a soft track (--mode mux) draws nothing,
+        # and nor does a run with no input video, which only writes the SRT (review of #532)
+        if args.mode != "mux" and args.input:
+            require_font_file(brand["font_file"], "the --brand file's font_file")
         args.fonts_dir = str(Path(brand["font_file"]).parent)
     if not (args.srt or args.ass or args.text or args.transcribe):
         die("give one of --srt, --ass, --text or --transcribe")
@@ -1586,9 +1591,12 @@ def main() -> int:
             up_front.append((args.write_ass or os.path.splitext(planned_out)[0] + ".ass", "ASS"))
         if args.ass and args.offset and os.path.exists(args.ass):
             up_front.append((os.path.splitext(planned_out)[0] + "_offset.ass", "offset ASS"))
-        # -o naming the input itself keeps its own, more specific refusal (_check_no_overwrite_input)
-        if os.path.realpath(planned_out) != os.path.realpath(args.input):
-            up_front.append((planned_out, "video"))
+        # -o naming the input (the same name, a hard link, another case on a case-insensitive
+        # volume) is refused here, before any sidecar or transcript is written: run()'s own guard
+        # came after the .srt was already beside it (review of #530)
+        if same_file(planned_out, args.input):
+            refuse_output_is_input(planned_out, args.input, why="the captioned video would replace the source")
+        up_front.append((planned_out, "video"))
     claim(up_front)
     if args.transcribe:
         # the sidecar goes next to the output like the --text one, not into the source folder

package/scripts/graphics.py

@@ -47,7 +47,7 @@ from _common import (guard_sidecar, require_filter, aac_args, add_common, brand_
 from _common.emit import note, warn
 from _common.alpha import (add_alpha_args, audio_line, check_alpha_args, decoder_args_for, default_ext, finish_chain,
                            report as alpha_report, source_alpha, source_format, tag_args, video_line)
-from _common.fonts import font_choice, record_font_choice
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common.probe import display_size, square_pixels, square_pixels_note
 from _ass_overlay import text_overlay_ass, EMOJI_SENTINEL
 from _common import drawtext_fontfile  # noqa: E402
@@ -175,6 +175,9 @@ def main(force_route: Optional[str] = None) -> int:
     if args.brand and style.get("color") and not args.text_color:
         text_c = color_hex(style["color"])
     args.lang = args.lang or (brand.get("lang") if args.brand else None)
+    # checked where text is drawn with it: the progress template draws a bar only (review of #532)
+    if args.template != "progress" and (args.font_file or brand.get("font_file")):
+        require_font_file(args.font_file or brand["font_file"], "--font-file" if args.font_file else "the --brand file's font_file")
     # a font that covers the text before drawtext renders boxes instead of glyphs (1.12)
     _script, script_file, _family = script_font_for_text(
         " ".join(t for t in (args.name, args.title, args.subtitle, args.text, args.top, args.bottom) if t),

package/scripts/grid.py

@@ -32,7 +32,7 @@ from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
 from _common.fonts import script_font_for_text  # noqa: E402
-from _common.probe import square_pixels  # noqa: E402
+from _common.probe import is_still_input, square_pixels, still_loop_args  # noqa: E402
 from _common.wrap import text_width_em  # noqa: E402
 from _common.emit import input_length  # noqa: E402
 from _common.decision import conform_output_t, conform_to_length  # noqa: E402
@@ -116,8 +116,15 @@ def main() -> int:
     if args.audio_from is not None and not metas[args.audio_from].get("audio"):
         die(f"--audio-from {args.audio_from}: {args.inputs[args.audio_from]} has no audio stream")
 
-    durations = [input_length(m) for m in metas]
+    # a still picture has no length of its own: it lasts as long as the grid (#510). Counted as a
+    # clip of 0 s, it made the grid 0 s long, and the run ended in a traceback on the empty file.
+    stills = [is_still_input(m) for m in metas]
+    if all(stills):
+        die("every cell is a still picture, so the grid has no length to take from a clip", kind="input",
+            hint="give at least one video cell, or make a clip of a still first (insert.py STILL --duration T)")
+    durations = [input_length(m) for m, still in zip(metas, stills) if not still]
     target_duration = max(durations) if args.pad else min(durations)
+    durations = [target_duration if still else input_length(m) for m, still in zip(metas, stills)]
 
     # each label is drawn with a font that covers its own script, as every other text-drawing tool
     # picks one (through 3.1.3 a Japanese or Thai filename came out as tofu, #411); `font_used` is
@@ -139,11 +146,13 @@ def main() -> int:
     if args.label == "auto" and cut:
         note(f"{len(cut)} cell label(s) wider than the {args.cell_width} px cell at --font-size "
              f"{args.font_size} were shortened from the end with an ellipsis")
-    output = args.output or default_output(args.inputs[0], "grid")
+    # named after the first cell; a still there would give its own extension (white_grid.png), and
+    # the image muxer cannot write the grid's frames to one file name (review of #532)
+    output = args.output or default_output(args.inputs[0], "grid", "mp4" if stills[0] else None)
 
     cmd = ffmpeg_base()
-    for p in args.inputs:
-        cmd += ["-i", p]
+    for p, still in zip(args.inputs, stills):
+        cmd += (still_loop_args(p, target_duration) if still else []) + ["-i", p]
 
     # each cell converted by its own tags to the BT.709 the grid is tagged with (a BT.601 or an RGB
     # input): without it 5.1/6.1 relabelled them, and 7.1+ converted cells to one another's matrix.

package/scripts/metadata.py

@@ -219,8 +219,11 @@ def main() -> int:
     args = ap.parse_args()
     apply_common(args)
     if args.auto_chapters:  # the only mode that writes them
-        guard_sidecar(args.chapters_out, args.input, siblings=(args.description_out, args.output))
-        guard_sidecar(args.description_out, args.input, siblings=(args.output,))
+        # against the video this run writes, the default name too (A6, #465: --chapters-out at
+        # input_meta.mp4 wrote the chapter text over the video it had just written)
+        video_out = args.output or default_output(args.input, "meta", Path(args.input).suffix.lstrip(".") or "mp4")
+        guard_sidecar(args.chapters_out, args.input, siblings=(args.description_out, video_out))
+        guard_sidecar(args.description_out, args.input, siblings=(video_out,))
 
     if args.chapters and args.clear_chapters:
         die("--chapters and --clear-chapters exclude each other")

package/scripts/overlay.py

@@ -46,7 +46,7 @@ from _common.probe import display_size, refuse_not_a_still, square_pixels, squar
 from _common.drawtext import shaping_refusal
 from _common.wrap import wrap_text
 from _common import text_width_em
-from _common.fonts import font_choice, record_font_choice
+from _common.fonts import font_choice, record_font_choice, require_font_file
 from _common import drawtext_fontfile  # noqa: E402
 
 # Per-edge margins: a platform's UI does not cover the same fraction of every edge (TikTok's
@@ -361,6 +361,7 @@ def main() -> int:
     # at --font-size), so a project that asked for 200 px text completed with the 42 px default.
     if args.text and not (args.image or args.video) and (args.scale is not None or args.scale_percent is not None):
         die("--scale and --scale-percent size an image, logo or video layer; text size is --font-size", kind="input")
+    font_file_from = "--font-file"  # what the refusal of a font file that is not one names
     if args.brand:
         if args.margin == ap.get_default("margin"):
             args.margin = int(brand.get("safe_margin", args.margin))
@@ -368,6 +369,7 @@ def main() -> int:
             args.font = brand.get("font", args.font)
         if not args.font_file and brand.get("font_file"):
             args.font_file = brand["font_file"]
+            font_file_from = "the --brand file's font_file"
     if args.text:
         # 1.15: drawtext never reorders or re-clusters (no harfbuzz), so Devanagari matras and
         # Thai/Lao mark stacking come out wrong on EVERY build. A wrong frame is not a delivery:
@@ -393,6 +395,8 @@ def main() -> int:
                      "a font without the glyph draws an empty box (monochrome at best with one). --emoji none "
                      "leaves them out; caption.py/graphics.py composite colour PNGs with --emoji-assets",
                      "emoji_monochrome")
+    if args.text and args.font_file:
+        require_font_file(args.font_file, font_file_from)
     script_file = script_family = None
     if args.text and not args.font_file:
         # 1.12: non-Latin overlay text picks a font by script, so a title in Japanese, Korean,
@@ -533,6 +537,11 @@ def main() -> int:
         # a --start/--end window is in the layer's position, which is evaluated on the main
         # picture's frames; overlay's enable is evaluated on the layer's frames too
         ov = f"overlay={windowed_overlay_x(x, enable) if enable else x}:{y}" + (overlay_format(meta) or ":format=auto")
+        if not meta.get("duration"):
+            # nothing to bound by -t: the overlay ends with the main picture. -shortest alone never
+            # ended a still main (one picture, no duration): overlay kept repeating it under the
+            # looped layer and the run went on until its timeout (#510)
+            ov += ":shortest=1"
         # -loop 1 turns the still into a timed stream so fade/enable expressions see real timestamps
         cmd = ffmpeg_base() + ["-i", args.input, "-loop", "1", *still_input_args(args.image), "-i", args.image]
         # the RGBA still is converted to the BT.709 the output is tagged with (overlay's own

package/scripts/render.py

@@ -76,7 +76,7 @@ from export import PRESETS, PLATFORM_OF
 from _platforms import PLATFORMS, caption_defaults, resolve as resolve_platform
 from _common import guard_sidecar, STATE, add_common, aspect_ratio, brand_caption_style, load_brand, apply_common, child_args, die, emit as _emit, info, option_args, probe, require_tool, run, run_tool, place_output, refuse_output_is_input, _check_existing_output, _check_output_path, fingerprint, PLAN_VERSION, ffmpeg_version, X264_PRESETS
 from _common.runner import HW_ENV, HW_FORCED_ENV, add_hw_orchestrator_args, child_exit_code, found_exe, kept_clause, kept_deliverables, mark_delivered, owned_identity, read_json, remember_written
-from _common.emit import absorb_stage, audit, record_fallback, record_skip, refuse, warn
+from _common.emit import absorb_stage, audit, is_output_shape_flag, record_fallback, record_skip, refuse, stderr_records, warn
 from _common.decision import rebase_project_paths
 import subprocess
 from _contract import CONTRACT_VERSION
@@ -405,9 +405,7 @@ def render_pack(names: List[str], args) -> int:
             doc = {}
         # the child ran with --json, so its planned commands come back in the document: the pack
         # is the one path that writes seven files, and --dry-run has to show all of them
-        for line in proc.stderr.splitlines():
-            if line.startswith("$ ") or line.startswith("[dry-run]"):
-                STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+        STATE.commands.extend(text for is_command, text in stderr_records(proc.stderr) if is_command)
         STATE.commands.extend(str(c) for c in (doc.get("commands") or []))
         absorb_stage(name, doc)
         out = doc.get("output") or dest_out
@@ -806,9 +804,9 @@ def sh(script: str, *argv: Any, extra: List[str] = None, stage: str = None) -> s
     cmd = [str(HERE / script)] + [str(a) for a in argv] + (extra or []) + own + child_args() + ["--json"]
     info("→ " + " ".join(os.path.basename(c) if i < 1 else c for i, c in enumerate(cmd[:-1])))
     proc = run_tool(cmd)
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ ") or line.startswith("[dry-run]"):
-            STATE.commands.append(line[2:] if line.startswith("$ ") else line)
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command:
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:
@@ -1212,7 +1210,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         os.chdir(plan["cwd"])
     if not isinstance(plan.get("argv"), list):
         _reject_plan(path, digest, "plan_argv_invalid", f"{path}: argv must be a list", argv_type=type(plan.get("argv")).__name__)
-    argv = [str(a) for a in plan["argv"]]
+    # a plan an earlier version recorded with --json-brief (A181): the tool is run for its full
+    # document, as every plan written now asks for
+    argv = [str(a) for a in plan["argv"] if not is_output_shape_flag(str(a))]
     if STATE.dry_run:
         for c in plan.get("commands") or []:
             STATE.commands.append(c)
@@ -1226,9 +1226,9 @@ def execute_plan(plan: Dict[str, Any], path: str) -> int:
         return 0
     info(f"executing plan {path}: {tool} " + " ".join(argv))
     proc = run_tool([str(script)] + argv + child_args() + ["--json"])
-    for line in proc.stderr.splitlines():
-        if line.startswith("$ "):
-            STATE.commands.append(line[2:])
+    for is_command, line in stderr_records(proc.stderr):
+        if is_command and not line.startswith("[dry-run]"):
+            STATE.commands.append(line)
         elif line.strip():
             info("    " + line)
     try:

package/scripts/report.py

@@ -14,6 +14,7 @@ import base64
 import html
 import json
 import os
+import re
 import sys
 import tempfile
 from pathlib import Path
@@ -145,6 +146,10 @@ def md_cells(line: str) -> List[str]:
     return cells
 
 
+# the columns of render.py's render_pack() table, in its order
+PACK_HEADER = ["platform", "file", "size", "duration", "check"]
+
+
 def pack_report(args) -> int:
     """render.py --template all writes <stem>_pack.md: one row per destination. This renders the
     same rows as HTML, so a pack can be handed over the way a single delivery report is -- no
@@ -152,19 +157,37 @@ def pack_report(args) -> int:
     text = read_text_or_die(args.pack, "--pack")
     rows: List[List[str]] = []
     header: List[str] = []
+    delimiter: Optional[List[str]] = None
     for line in text.split("\n"):
         line = line.strip()
         if not line.startswith("|"):
+            if header:
+                break  # the table ended: a later table in the file is not the pack's
             continue
         cells = md_cells(line)
-        if all(set(c) <= set("-: ") for c in cells):
-            continue
         if not header:
             header = cells
+        elif delimiter is None:
+            delimiter = cells  # the line under the header, whatever it is: checked below
         else:
+            # every later line is a row, a separator-like one too: `| | |` after a row was skipped
+            # as a delimiter and never counted (review of #532)
             rows.append(cells)
+    # the table render.py --template all writes, and only that one: any Markdown table was taken
+    # and handed over as a pack report with `verified: true` (#510)
+    if header and header != PACK_HEADER:
+        die(f"{args.pack}: its table's columns are {' | '.join(header)}, not the pack table's "
+            f"({' | '.join(PACK_HEADER)}) that render.py --template all writes", kind="input")
+    # a header with a row under it and no delimiter line is no Markdown table (review of #532)
+    if header and delimiter is not None and not (
+            len(delimiter) == len(PACK_HEADER) and all(re.fullmatch(r":?-+:?", c) for c in delimiter)):
+        die(f"{args.pack}: the line under the pack table's header is not its delimiter row "
+            f"(|---|---|---|---|---|), so it is no Markdown table", kind="input")
+    bad = next((i for i, r in enumerate(rows) if len(r) != len(PACK_HEADER)), None)
+    if bad is not None:
+        die(f"{args.pack}: row {bad + 1} of the pack table has {len(rows[bad])} cells, not {len(PACK_HEADER)}", kind="input")
     if not rows:
-        die(f"{args.pack}: no pack table found (expected the Markdown table render.py --template all writes)")
+        die(f"{args.pack}: no pack table found (expected the Markdown table render.py --template all writes)", kind="input")
     title = args.title or f"Social pack — {Path(args.pack).stem.replace('_pack', '')}"
     output = args.output or str(Path(args.pack).with_suffix(".html"))
     guard_sidecar(output, args.pack)

package/scripts/silence.py

@@ -29,7 +29,7 @@ from _common import (filler_spans, FILLER_WORDS, FILLER_AMBIGUOUS, FILLER_DISCOU
 from _common import asr as _asr
 from _common.emit import warn
 from _common.asr import _dicts
-from _common.runner import parse_json, replace_checked
+from _common.runner import parse_json, replace_checked, same_file
 from _common import guard_sidecar, refuse_existing_outputs, refuse_output_is_input, _check_output_path
 from _common.emit import refuse
 from _common import detect_silences as detect, STATE, add_common, apply_common, default_output, die, emit, info, is_audio_output, print_json, probe, X264_PRESETS, measured_level_dbfs, fmt_secs
@@ -672,7 +672,7 @@ def main() -> int:
         # --overwrite allows replacing an old map, never the source, the cut or the EDL
         refuse_output_is_input(args.timemap, *[p for p in (args.input, args.words, args.filler_words) if p])
         for flag, other in (("-o", args.output), ("--edl", args.edl), ("--plan", getattr(args, "plan", None))):
-            if other and os.path.realpath(other) == os.path.realpath(args.timemap):
+            if other and same_file(other, args.timemap):
                 refuse("input", "timemap_path_taken",
                        f"--timemap {args.timemap} is the same file as {flag}; give the map its own path",
                        timemap=args.timemap, flag=flag, path=other)

package/scripts/verify.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from _common import STATE, add_common, apply_common, die, emit, guard_sidecar, info, probe, refuse_output_is_input, MEDIA_EXT as _MEDIA_EXT
+from _common.runner import _stop_child, _unwatch, _watch
 
 HERE = Path(__file__).resolve().parent
 # _common's one list less the stills, as batch.py walks a folder: verify kept a list of its own,
@@ -140,13 +141,24 @@ def step(name: str, argv: List[str], timeout: float) -> Dict:
         if not ok:
             r.update(kind="verification", reason="hdr_lost", message=r["error"])
         return r
+    child = subprocess.Popen([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace")
+    # watched like run_tool()'s child (review of #530): a SIGTERM or Ctrl-C to verify.py stops the
+    # step through stop_children() -- its own handler removes its partial output and lock --
+    # instead of leaving it running and writing after verify.py has exited
+    _watch(child, [])
     try:
-        proc = subprocess.run([sys.executable, str(HERE / argv[0])] + argv[1:] + _forwarded(argv) + ["--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                              text=True, encoding="utf-8", errors="replace", timeout=timeout or None)
+        out, err = child.communicate(timeout=timeout or None)
+        proc = subprocess.CompletedProcess(child.args, child.returncode, out, err)
     except subprocess.TimeoutExpired:
+        # stopped as run_tool() stops a sibling script past its ceiling (#465 A183's sweep): the
+        # SIGKILL subprocess.run() sent left the step's partial output and output lock in --out
+        _stop_child(child)
         msg = f"timeout after {timeout:.0f}s"
         return {"step": name, "ok": False, "seconds": round(time.time() - t0, 1), "error": msg,
                 "kind": "timeout", "reason": "step_timeout", "message": msg}
+    finally:
+        _unwatch(child)
     try:
         doc = json.loads(proc.stdout)
     except ValueError:
@@ -198,10 +210,27 @@ def main() -> int:
     files = collect(args.paths)
     FORWARD.update(overwrite=STATE.overwrite, fast=STATE.fast)
     tmp = None
+    started = {"step": False}
     if args.out:
         # made first, so a --report inside a new --out folder passes the guard below (#413 review)
         outdir = Path(args.out)
+        made = [d for d in (outdir, *outdir.parents) if not d.exists()]
         outdir.mkdir(parents=True, exist_ok=True)
+        if made:
+            import atexit
+
+            def _remove_unused_dirs() -> None:
+                # a run refused before its first step (a --report guard) leaves no empty --out
+                # folder behind, as batch.py leaves no out/ (#465 A187's sibling); once a step has
+                # run the folder is the caller's, empty or not
+                if started["step"]:
+                    return
+                for d in made:  # deepest first
+                    try:
+                        d.rmdir()
+                    except OSError:
+                        pass
+            atexit.register(_remove_unused_dirs)
     if args.report:
         # a file this run writes itself (#408): not one of the media it verifies (a folder's
         # files included), nor an existing file without --overwrite
@@ -301,6 +330,7 @@ def main() -> int:
             refuse_output_is_input(out, *every_input, why=f"it is where verify writes the {name!r} step's output for {str(f)!r}")
 
     results = []
+    started["step"] = True
     for f, entry, plan, cues in jobs:
         info(f"=== {f}")
         if cues: