@oh-story/dsh 0.1.8 → 0.1.9

package/lib/video-recap/skills/video-cut/scripts/lib.py

@@ -1,4 +1,5 @@
 """Self-contained utilities for the video-cut skill (no cross-skill imports)."""
+import math
 import os
 import subprocess
 
@@ -12,20 +13,27 @@ def env_bool(name, default):
     val = os.environ.get(name)
     if val is None:
         return default
-    return val.strip().lower() in ("1", "true", "yes")
+    text = val.strip().lower()
+    if text in ("1", "true", "yes"):
+        return True
+    if text in ("0", "false", "no"):
+        return False
+    raise ValueError(f"{name} must be 1/true/yes or 0/false/no, got {val!r}")
 
 
 def env_float(name, default, min_val=None):
-    """Read an env var as a float, with an optional minimum clamp."""
+    """Read an env var as a float, rejecting malformed or below-minimum values."""
     val = os.environ.get(name)
     if val is None:
         return default
     try:
-        result = float(val.strip())
-    except (ValueError, AttributeError):
-        return default
-    if min_val is not None:
-        result = max(min_val, result)
+        result = float(val)
+    except ValueError as exc:
+        raise ValueError(f"{name} must be a number, got {val!r}") from exc
+    if not math.isfinite(result):
+        raise ValueError(f"{name} must be finite, got {val!r}")
+    if min_val is not None and result < min_val:
+        raise ValueError(f"{name} must be >= {min_val}, got {val!r}")
     return result
 
 
@@ -49,29 +57,19 @@ CONFIG = {
 
 
 def run_cmd(cmd, **kwargs):
-    """Run a command and return the CompletedProcess (stdout/stderr captured)."""
-    if isinstance(cmd, list):
-        display_parts = []
-        for part in cmd:
-            text = str(part)
-            display_parts.append(text if len(text) <= 240 else text[:237] + "...")
-        display = " ".join(display_parts)
-    else:
-        display = str(cmd)
-        if len(display) > 2000:
-            display = display[:1997] + "..."
+    """Run a command list and return the CompletedProcess (stdout/stderr captured)."""
+    display = " ".join(
+        str(part) if len(str(part)) <= 240 else str(part)[:237] + "..." for part in cmd
+    )
     log(f"运行: {display}")
     return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
 
 
 def get_video_duration(video_path):
-    """Return media duration in seconds via ffprobe, or 0.0 on failure."""
-    cmd = ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
+    """Return media duration in seconds via ffprobe."""
+    cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration",
            "-of", "csv=p=0", str(video_path)]
     result = run_cmd(cmd)
     if result.returncode != 0:
-        return 0.0
-    try:
-        return float(result.stdout.strip())
-    except (TypeError, ValueError):
-        return 0.0
+        raise RuntimeError(f"ffprobe 无法读取时长: {video_path}: {result.stderr.strip()}")
+    return float(result.stdout.strip())

package/lib/video-recap/skills/video-cut/scripts/media_geometry.py

@@ -2,7 +2,6 @@
 
 import json
 
-
 from lib import run_cmd
 
 
@@ -24,71 +23,42 @@ def _has_audio_stream(video_path):
 
 
 class VideoGeometry(tuple):
-    """Tuple-compatible geometry with probe facts attached for QC callers."""
+    """Tuple-compatible (width, height, fps) with probe facts attached for QC callers."""
 
-    def __new__(cls, width, height, fps, facts=None):
+    def __new__(cls, width, height, fps, facts):
         obj = super().__new__(cls, (width, height, fps))
-        obj.facts = facts or {}
+        obj.facts = facts
         return obj
 
 
 def _parse_ratio(value):
+    """ffprobe aspect ratios are 'N:D' (or 'N/D'); '0:1' and 'N/A' mean unknown."""
     if value in (None, "", "0:1", "0/1", "N/A"):
         return None
-    text = str(value)
-    sep = ":" if ":" in text else "/" if "/" in text else None
-    if not sep:
-        try:
-            ratio = float(text)
-            return ratio if ratio > 0 else None
-        except ValueError:
-            return None
-    left, _, right = text.partition(sep)
-    try:
-        num, den = float(left), float(right)
-    except ValueError:
-        return None
+    left, _, right = str(value).replace("/", ":").partition(":")
+    num, den = float(left), float(right)
     return num / den if den > 0 and num > 0 else None
 
 
 def _stream_rotation(stream):
-    candidates = []
-    tags = stream.get("tags") if isinstance(stream.get("tags"), dict) else {}
+    """Rotation from the legacy `rotate` tag or the display-matrix side data, else 0."""
+    tags = stream.get("tags", {})
     if "rotate" in tags:
-        candidates.append(tags.get("rotate"))
-    for side_data in stream.get("side_data_list") or []:
-        if isinstance(side_data, dict):
-            candidates.append(side_data.get("rotation"))
-    for value in candidates:
-        try:
-            return int(round(float(value))) % 360
-        except (TypeError, ValueError):
-            continue
+        return int(round(float(tags["rotate"]))) % 360
+    for side_data in stream.get("side_data_list", []):
+        if "rotation" in side_data:
+            return int(round(float(side_data["rotation"]))) % 360
     return 0
 
 
 def _fps_from_rate(rate):
-    if not rate or "/" not in str(rate):
-        return 0.0
-    num, _, den = str(rate).partition("/")
-    try:
-        num_f, den_f = float(num), float(den)
-        return num_f / den_f if den_f > 0 else 0.0
-    except ValueError:
-        return 0.0
-
+    """ffprobe frame rates are 'N/D' fractions; '0/0' means unknown."""
+    num, _, den = rate.partition("/")
+    return float(num) / float(den) if float(den) > 0 else 0.0
 
-def _geometry_from_stream(stream, *, fallback=False):
-    coded_width = coded_height = 0
-    try:
-        coded_width = int(float(stream.get("width") or 0))
-        coded_height = int(float(stream.get("height") or 0))
-    except (TypeError, ValueError):
-        coded_width = coded_height = 0
-    if coded_width <= 0 or coded_height <= 0:
-        coded_width, coded_height = 1280, 720
-        fallback = True
 
+def _geometry_from_stream(stream):
+    coded_width, coded_height = stream["width"], stream["height"]
     parsed_sar = _parse_ratio(stream.get("sample_aspect_ratio"))
     dar = _parse_ratio(stream.get("display_aspect_ratio"))
     rotation = _stream_rotation(stream)
@@ -110,8 +80,8 @@ def _geometry_from_stream(stream, *, fallback=False):
         display_width, display_height = display_height, display_width
 
     width, height = _clamp_even_geometry(round(display_width), round(display_height))
-    fps = _fps_from_rate(stream.get("r_frame_rate")) or _fps_from_rate(
-        stream.get("avg_frame_rate")
+    fps = _fps_from_rate(stream["r_frame_rate"]) or _fps_from_rate(
+        stream.get("avg_frame_rate", "0/0")
     )
     if not 0 < fps <= 120:
         fps = 30.0
@@ -121,27 +91,25 @@ def _geometry_from_stream(stream, *, fallback=False):
         "width": width,
         "height": height,
         "fps": round(fps, 3),
-        "sample_aspect_ratio": stream.get("sample_aspect_ratio") or "1:1",
-        "sample_aspect_ratio_float": round(float(sar), 6),
+        "sample_aspect_ratio": stream.get("sample_aspect_ratio", "1:1"),
+        "sample_aspect_ratio_float": round(sar, 6),
         "display_aspect_ratio": stream.get("display_aspect_ratio"),
-        "display_aspect_ratio_float": round(float(dar or 0.0), 6),
+        "display_aspect_ratio_float": round(dar or 0.0, 6),
         "display_aspect_source": aspect_source,
         "display_width": width,
         "display_height": height,
         "rotation": rotation,
         "rotation_swaps_axes": rotation_swaps_axes,
-        "fallback": bool(fallback),
     }
     return VideoGeometry(width, height, round(fps, 3), facts)
 
 
 def _probe_video_geometry(video_path):
-    """Best-effort iterable (width, height, fps), rotation/SAR/DAR-aware.
+    """Display geometry (width, height, fps) of the first video stream, rotation/SAR/DAR-aware.
 
-    Returned value unpacks like the historical 3-tuple while exposing `.facts`
-    for QC. Used to normalize heterogeneous multi-source segments to one
-    square-pixel geometry before concat (ffmpeg's concat filter rejects
-    mismatched width/height/SAR/pixel-format/fps).
+    Unpacks like a 3-tuple while exposing `.facts` for QC. Used to normalize heterogeneous
+    multi-source segments to one square-pixel geometry before concat (ffmpeg's concat filter
+    rejects mismatched width/height/SAR/pixel-format/fps).
     """
     cmd = [
         "ffprobe",
@@ -155,38 +123,13 @@ def _probe_video_geometry(video_path):
         "json",
         str(video_path),
     ]
-    try:
-        result = run_cmd(cmd)
-    except Exception:  # noqa: BLE001 - probing is best-effort; fall back to defaults
-        result = None
-    if (
-        result is not None
-        and getattr(result, "returncode", 1) == 0
-        and (result.stdout or "").strip()
-    ):
-        try:
-            payload = json.loads(result.stdout)
-            streams = payload.get("streams") or []
-            if streams:
-                return _geometry_from_stream(streams[0])
-        except (AttributeError, TypeError, ValueError):
-            pass
-
-    # Backward-compatible fallback for tests/mocks that still return CSV output.
-    stream = {}
-    if result is not None and (result.stdout or "").strip():
-        parts = result.stdout.strip().splitlines()[0].split(",")
-        if len(parts) >= 2:
-            stream["width"], stream["height"] = parts[0], parts[1]
-        if len(parts) >= 3:
-            stream["r_frame_rate"] = parts[2]
-        if len(parts) >= 4 and parts[3] not in ("", "N/A"):
-            stream["tags"] = {"rotate": parts[3]}
-        if len(parts) >= 5 and parts[4] not in ("", "N/A"):
-            stream["sample_aspect_ratio"] = parts[4]
-        if len(parts) >= 6 and parts[5] not in ("", "N/A"):
-            stream["display_aspect_ratio"] = parts[5]
-    return _geometry_from_stream(stream, fallback=True)
+    result = run_cmd(cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffprobe 无法读取视频几何信息: {video_path}: {result.stderr.strip()}")
+    streams = json.loads(result.stdout).get("streams", [])
+    if not streams:
+        raise RuntimeError(f"没有视频流: {video_path}")
+    return _geometry_from_stream(streams[0])
 
 
 def _orientation(width, height):
@@ -198,91 +141,53 @@ def _orientation(width, height):
 
 
 def _fps_bucket(fps):
-    if not fps or fps <= 0:
-        return 30.0
     common = [23.976, 24.0, 25.0, 29.97, 30.0, 50.0, 59.94, 60.0]
-    nearest = min(common, key=lambda x: abs(float(fps) - x))
-    return nearest if abs(float(fps) - nearest) <= 0.15 else round(float(fps))
+    nearest = min(common, key=lambda x: abs(fps - x))
+    bucket = nearest if abs(fps - nearest) <= 0.15 else round(fps)
+    return max(1.0, min(60.0, bucket))
 
 
-def _clamp_even_geometry(width, height, max_height=None):
-    width = max(2, int(width) - int(width) % 2)
-    height = max(2, int(height) - int(height) % 2)
-    max_height = int(max_height or 0)
-    if max_height > 0 and height > max_height:
-        scale = max_height / height
-        height = max_height - max_height % 2
-        width = max(2, int(width * scale))
-        width -= width % 2
-    return width, height
+def _clamp_even_geometry(width, height):
+    return max(2, width - width % 2), max(2, height - height % 2)
 
 
-def _select_output_geometry(source_paths, clips, max_height=None):
+def _select_output_geometry(source_paths, clips):
     """Deterministically select canvas/fps from all used sources, not just the first."""
     used = {}
-    for clip in clips or []:
-        path = str(clip.get("source_path") or "")
-        if not path:
-            continue
-        used[path] = used.get(path, 0.0) + max(0.0, float(clip.get("duration") or 0.0))
-    if not used:
-        for path in source_paths or []:
-            used[str(path)] = 0.0
+    for clip in clips:
+        if "source_path" in clip:
+            used[clip["source_path"]] = used.get(clip["source_path"], 0.0) + clip["duration"]
+    if not used:  # single-source plans carry no per-clip source_path
+        used = {str(path): 0.0 for path in source_paths}
     rows = []
     for path in sorted(used):
         probed = _probe_video_geometry(path)
         width, height, fps = probed
-        facts = dict(getattr(probed, "facts", {}) or {})
-        facts.setdefault("width", width)
-        facts.setdefault("height", height)
-        facts.setdefault("fps", fps)
-        facts.setdefault("rotation", 0)
-        facts.setdefault("sample_aspect_ratio", "1:1")
+        facts = probed.facts
         rows.append(
             {
                 "path": path,
                 "source_id": next(
-                    (
-                        str(c.get("source_id"))
-                        for c in clips or []
-                        if str(c.get("source_path") or "") == path
-                        and c.get("source_id") is not None
-                    ),
-                    None,
+                    (c["source_id"] for c in clips if c.get("source_path") == path), None
                 ),
                 "used_duration": round(used[path], 3),
                 "width": width,
                 "height": height,
-                "coded_width": facts.get("coded_width", width),
-                "coded_height": facts.get("coded_height", height),
-                "display_width": facts.get("display_width", width),
-                "display_height": facts.get("display_height", height),
+                "coded_width": facts["coded_width"],
+                "coded_height": facts["coded_height"],
+                "display_width": facts["display_width"],
+                "display_height": facts["display_height"],
                 "area": width * height,
                 "fps": fps,
-                "fps_bucket": min(60.0, _fps_bucket(fps)),
+                "fps_bucket": _fps_bucket(fps),
                 "orientation": _orientation(width, height),
-                "rotation": facts.get("rotation", 0),
-                "sample_aspect_ratio": facts.get("sample_aspect_ratio", "1:1"),
-                "sample_aspect_ratio_float": facts.get(
-                    "sample_aspect_ratio_float", 1.0
-                ),
-                "display_aspect_ratio": facts.get("display_aspect_ratio"),
-                "rotation_swaps_axes": bool(facts.get("rotation_swaps_axes", False)),
+                "rotation": facts["rotation"],
+                "sample_aspect_ratio": facts["sample_aspect_ratio"],
+                "sample_aspect_ratio_float": facts["sample_aspect_ratio_float"],
+                "display_aspect_ratio": facts["display_aspect_ratio"],
+                "rotation_swaps_axes": facts["rotation_swaps_axes"],
             }
         )
-    if not rows:
-        return (
-            1280,
-            720,
-            30.0,
-            {
-                "width": 1280,
-                "height": 720,
-                "fps": 30.0,
-                "reason": "fallback_no_sources",
-                "source_id": None,
-            },
-        )
 
     orientation_duration = {}
     for row in rows:
@@ -298,10 +203,9 @@ def _select_output_geometry(source_paths, clips, max_height=None):
         ),
         reverse=True,
     )[0][0]
-    eligible = [r for r in rows if r["orientation"] == chosen_orientation] or rows
+    eligible = [r for r in rows if r["orientation"] == chosen_orientation]
     selected = sorted(
-        eligible,
-        key=lambda r: (-r["area"], str(r.get("source_id") or ""), r["path"]),
+        eligible, key=lambda r: (-r["area"], r["source_id"] or "", r["path"])
     )[0]
 
     fps_duration = {}
@@ -309,33 +213,26 @@ def _select_output_geometry(source_paths, clips, max_height=None):
         fps_duration[row["fps_bucket"]] = (
             fps_duration.get(row["fps_bucket"], 0.0) + row["used_duration"]
         )
-    fps = sorted(fps_duration.items(), key=lambda kv: (kv[1], kv[0]), reverse=True)[0][
-        0
-    ]
-    fps = max(1.0, min(60.0, float(fps or 30.0)))
+    fps = sorted(fps_duration.items(), key=lambda kv: (kv[1], kv[0]), reverse=True)[0][0]
 
-    width, height = _clamp_even_geometry(
-        selected["width"], selected["height"], max_height=max_height
-    )
+    width, height = selected["width"], selected["height"]
     reason = {
         "width": width,
         "height": height,
         "fps": round(fps, 3),
         "reason": "weighted_orientation_area_fps",
-        "source_id": selected.get("source_id"),
+        "source_id": selected["source_id"],
         "source_path": selected["path"],
         "orientation": chosen_orientation,
-        "orientation_used_duration": round(
-            orientation_duration.get(chosen_orientation, 0.0), 3
-        ),
-        "fps_bucket_used_duration": round(fps_duration.get(fps, 0.0), 3),
-        "rotation": selected.get("rotation", 0),
-        "sample_aspect_ratio": selected.get("sample_aspect_ratio", "1:1"),
-        "display_aspect_ratio": selected.get("display_aspect_ratio"),
-        "coded_width": selected.get("coded_width"),
-        "coded_height": selected.get("coded_height"),
-        "display_width": selected.get("display_width"),
-        "display_height": selected.get("display_height"),
+        "orientation_used_duration": round(orientation_duration[chosen_orientation], 3),
+        "fps_bucket_used_duration": round(fps_duration[fps], 3),
+        "rotation": selected["rotation"],
+        "sample_aspect_ratio": selected["sample_aspect_ratio"],
+        "display_aspect_ratio": selected["display_aspect_ratio"],
+        "coded_width": selected["coded_width"],
+        "coded_height": selected["coded_height"],
+        "display_width": selected["display_width"],
+        "display_height": selected["display_height"],
         "sources": rows,
     }
     return width, height, round(fps, 3), reason

package/lib/video-recap/skills/video-cut/scripts/narration_mapping.py

@@ -4,51 +4,33 @@ from lib import log
 
 
 def source_time_to_output_time(source_time, clips):
-    """Map a source timestamp into the post-concat output timeline."""
-    ts = float(source_time)
+    """Map a source timestamp into the post-concat output timeline (None when cut away)."""
     for clip in clips:
         start = clip["source_start"]
         end = clip["source_end"]
-        if start <= ts <= end:
-            mapped = clip["output_start"] + (ts - start)
+        if start <= source_time <= end:
+            mapped = clip["output_start"] + (source_time - start)
             return round(max(clip["output_start"], min(mapped, clip["output_end"])), 3)
     return None
 
 
 def _clips_for_midpoint(start, end, clips):
-    mid = (float(start) + float(end)) / 2
+    mid = (start + end) / 2
     return [clip for clip in clips if clip["source_start"] <= mid <= clip["source_end"]]
 
 
 def map_narration_to_clips(narration, validated_plan, min_duration=0.3):
     """Convert source-time narration segments to edited-output timeline segments."""
-    clips = (
-        validated_plan["clips"] if isinstance(validated_plan, dict) else validated_plan
-    )
+    clips = validated_plan["clips"]
     mapped = []
-    for raw in narration or []:
-        if not isinstance(raw, dict):
-            continue
-        try:
-            source_start = float(raw.get("start"))
-            source_end = float(raw.get("end"))
-        except (TypeError, ValueError):
-            continue
-        text = str(raw.get("narration", "")).strip()
-        if source_end <= source_start or not text:
-            continue
+    for raw in narration:
+        source_start = raw["start"]
+        source_end = raw["end"]
         if raw.get("source_clip_id") is not None:
-            try:
-                requested_clip_id = int(raw.get("source_clip_id"))
-            except (TypeError, ValueError):
-                requested_clip_id = None
-            clip = next(
-                (c for c in clips if c.get("clip_id") == requested_clip_id), None
-            )
+            requested_clip_id = int(raw["source_clip_id"])
+            clip = next((c for c in clips if c["clip_id"] == requested_clip_id), None)
             if clip and not (
-                clip["source_start"]
-                <= ((source_start + source_end) / 2)
-                <= clip["source_end"]
+                clip["source_start"] <= (source_start + source_end) / 2 <= clip["source_end"]
             ):
                 clip = None
         else:
@@ -67,16 +49,12 @@ def map_narration_to_clips(narration, validated_plan, min_duration=0.3):
         if clipped_source_end - clipped_source_start < min_duration:
             log(f"  丢弃过短映射解说: {source_start:.1f}-{source_end:.1f}s")
             continue
-        output_start = source_time_to_output_time(clipped_source_start, [clip])
-        output_end = source_time_to_output_time(clipped_source_end, [clip])
-        if output_start is None or output_end is None or output_end <= output_start:
-            continue
         item = dict(raw)
         item["source_start"] = round(clipped_source_start, 3)
         item["source_end"] = round(clipped_source_end, 3)
         item["source_clip_id"] = clip["clip_id"]
-        item["start"] = output_start
-        item["end"] = output_end
+        item["start"] = source_time_to_output_time(clipped_source_start, [clip])
+        item["end"] = source_time_to_output_time(clipped_source_end, [clip])
         # Tag beats trimmed to a clip edge: their TEXT was written for a longer span and may
         # now describe footage that was cut away (a stale-text desync the lint surfaces).
         item["clamped"] = bool(
@@ -108,17 +86,15 @@ def lint_mapped_narration(
     enforces unless --allow-sparse-cut. Clamped beats are always blocking because their TTS
     sentence would be cut at a clip edge; sparse-cut intent never authorizes speech truncation.
     """
-    mapped = sorted(mapped or [], key=lambda s: float(s.get("start", 0.0)))
+    mapped = sorted(mapped, key=lambda s: s["start"])
     mapped_count = len(mapped)
-    original_count = int(original_count or 0)
     dropped = max(0, original_count - mapped_count)
     drop_ratio = dropped / original_count if original_count else 0.0
-    out_dur = float(output_duration or 0.0)
-    spm = mapped_count / (out_dur / 60) if out_dur > 0 else 0.0
-    gaps = [float(b["start"]) - float(a["end"]) for a, b in zip(mapped, mapped[1:])]
+    spm = mapped_count / (output_duration / 60) if output_duration > 0 else 0.0
+    gaps = [b["start"] - a["end"] for a, b in zip(mapped, mapped[1:])]
     max_gap = max(gaps) if gaps else 0.0
-    covered = sum(max(0.0, float(b["end"]) - float(b["start"])) for b in mapped)
-    coverage = covered / out_dur if out_dur > 0 else 0.0
+    covered = sum(max(0.0, b["end"] - b["start"]) for b in mapped)
+    coverage = covered / output_duration if output_duration > 0 else 0.0
 
     warnings = []
     if drop_ratio >= drop_ratio_limit:
@@ -149,7 +125,7 @@ def lint_mapped_narration(
                 "max_gap_limit_seconds": max_gap_seconds,
             }
         )
-    clamped = [b for b in mapped if isinstance(b, dict) and b.get("clamped")]
+    clamped = [b for b in mapped if b["clamped"]]
     if clamped:
         warnings.append(
             {
@@ -168,7 +144,7 @@ def lint_mapped_narration(
         "mapped_count": mapped_count,
         "dropped": dropped,
         "drop_ratio": round(drop_ratio, 2),
-        "output_duration": round(out_dur, 2),
+        "output_duration": round(output_duration, 2),
         "segments_per_minute": round(spm, 2),
         "max_gap_seconds": round(max_gap, 2),
         "coverage": round(coverage, 2),
@@ -180,12 +156,12 @@ def lint_mapped_narration(
 
 def update_cut_qc(plan, *, allow_duration_drift=False, duration_drift_allowed_by=None):
     """Populate clip_plan_validated.json['qc'] as the single cut QC source."""
-    qc = dict(plan.get("qc") or {})
-    warnings = list(qc.get("warnings") or [])
-    blocking = list(qc.get("blocking") or [])
-    total = float(plan.get("total_duration") or 0.0)
-    target = plan.get("target_duration")
-    if target in (None, ""):
+    qc = dict(plan.get("qc", {}))
+    warnings = list(qc.get("warnings", []))
+    blocking = list(qc.get("blocking", []))
+    total = plan["total_duration"]
+    target = plan["target_duration"]
+    if target is None:
         target_status = "missing"
         target_qc = {
             "status": target_status,
@@ -193,7 +169,6 @@ def update_cut_qc(plan, *, allow_duration_drift=False, duration_drift_allowed_by
             "total_duration": round(total, 3),
         }
     else:
-        target = float(target)
         ratio = total / target if target > 0 else 0.0
         if ratio < 0.85:
             target_status = "under"
@@ -237,13 +212,13 @@ def update_cut_qc(plan, *, allow_duration_drift=False, duration_drift_allowed_by
     qc["target_duration_status"] = target_status
     qc["target_duration"] = target_qc
     qc.setdefault("boundary_status", {})
-    qc["clip_count"] = len(plan.get("clips") or [])
+    qc["clip_count"] = len(plan["clips"])
     qc["total_duration"] = round(total, 3)
     if warnings:
         qc["warnings"] = warnings
     if blocking:
         qc["blocking"] = blocking
-    elif "blocking" in qc:
+    else:
         qc.pop("blocking", None)
     plan["qc"] = qc
     return plan