@codebend3r/che 1.0.0 → 1.2.0

package/bin/video/find-video-mkv-issues.py

@@ -20,27 +20,30 @@ needed now.
 from __future__ import annotations
 
 import sys
+from collections import Counter
+from collections.abc import Callable
 from pathlib import Path
+from typing import NamedTuple
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import probe_media
 from utils import (
     add_bool_flag,
     build_parser,
-    ffprobe_entries,
     format_bytes,
     info,
     iter_files,
     note,
+    note_settings,
     require_binary,
-    run,
     run_cli,
     scan_root,
     success,
     warning,
 )
 
-__version__ = "2.1.0"
+__version__ = "2.1.1"
 
 # (score penalty, note). An empty note means "penalise silently", matching the
 # shell version, which docked a point for ac3/eac3 without explaining why.
@@ -74,6 +77,22 @@ SUBTITLE_PENALTIES: dict[str, tuple[int, str]] = {
 }
 
 
+class Tier(NamedTuple):
+    floor: int  # the lowest score in the tier
+    label: str
+    logger: Callable[[str], None]
+
+
+# Best first: a score lands in the first tier it reaches. The labels double as
+# the summary rows, in this order.
+TIERS: tuple[Tier, ...] = (
+    Tier(9, "Excellent", success),
+    Tier(7, "Good", info),
+    Tier(4, "Poor", note),
+    Tier(0, "Bad", warning),
+)
+
+
 def rate_video(
     video_codec: str,
     audio_codec: str,
@@ -113,9 +132,9 @@ def rate_video(
     return score, ";".join(reasons) if reasons else "Excellent Plex compatibility"
 
 
-def as_int(value: str) -> int:
-    """ffprobe prints 'N/A' for absent fields; treat anything non-numeric as 0."""
-    return int(value) if value.isdigit() else 0
+def tier(score: int) -> Tier:
+    """The ``TIERS`` row for a 0-10 score."""
+    return next(row for row in TIERS if score >= row.floor)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -136,18 +155,14 @@ def main(argv: list[str] | None = None) -> int:
 
     require_binary("ffprobe", hint="Install FFmpeg: brew install ffmpeg")
 
-    if not args.path:
-        warning("--path is required")
-        parser.print_help()
-        return 1
-
+    # An empty --path reads "❌ --path is required" without the usage block
+    # the shell version printed after it.
     root = scan_root(args.path)
 
-    note(f"Scanning: {args.path}")
-    note(f"Recursive: {str(args.recursive).lower()}")
-    note("----------------------------------------------------")
+    note_settings(("Scanning", args.path), ("Recursive", args.recursive))
 
-    total = excellent = good = poor = bad = 0
+    total = 0
+    counts: Counter[str] = Counter()
 
     # macOS ._ sidecars are skipped: they are never real media, and ffprobing
     # each one would waste a subprocess per file on a NAS scan. The shell
@@ -159,70 +174,40 @@ def main(argv: list[str] | None = None) -> int:
         note("Checking:")
         print(f"  {path}", flush=True)
 
-        readable = run(["ffprobe", "-v", "error", str(path)], check=False, capture=True)
-        if readable.returncode != 0:
+        probe = probe_media(path)
+        if probe is None:
             warning("  Corrupt or unreadable file")
             print(flush=True)
-            bad += 1
+            counts["Bad"] += 1
             continue
 
-        video_codec = (
-            ffprobe_entries(
-                path, "stream=codec_name", stream="v:0", fmt="default=noprint_wrappers=1:nokey=1"
-            )
-            or "unknown"
-        )
-        audio_codec = (
-            ffprobe_entries(
-                path, "stream=codec_name", stream="a:0", fmt="default=noprint_wrappers=1:nokey=1"
-            )
-            or "unknown"
-        )
-        subtitle_codec = (
-            ffprobe_entries(
-                path, "stream=codec_name", stream="s:0", fmt="default=noprint_wrappers=1:nokey=1"
-            )
-            or "none"
-        )
-        width_raw = ffprobe_entries(
-            path, "stream=width", stream="v:0", fmt="default=noprint_wrappers=1:nokey=1"
-        )
-        bitrate_raw = ffprobe_entries(
-            path, "format=bit_rate", fmt="default=noprint_wrappers=1:nokey=1"
-        )
-        width = as_int(width_raw)
-        bitrate = as_int(bitrate_raw)
+        video_codec = probe.codec("video") or "unknown"
+        audio_codec = probe.codec("audio") or "unknown"
+        subtitle_codec = probe.codec("subtitle") or "none"
+        width = probe.width()
+        bitrate = probe.bit_rate()
 
         try:
             filesize = path.stat().st_size
         except OSError:
             filesize = 0
 
-        score, notes = rate_video(video_codec, audio_codec, subtitle_codec, width, bitrate)
+        score, notes = rate_video(
+            video_codec, audio_codec, subtitle_codec, width or 0, bitrate or 0
+        )
 
         print(f"  Size      : {format_bytes(filesize)}", flush=True)
         print(f"  Video     : {video_codec}", flush=True)
         print(f"  Audio     : {audio_codec}", flush=True)
         print(f"  Subtitles : {subtitle_codec}", flush=True)
-        # `is not None` rather than truthiness: the shell version gated on the
-        # value being numeric, so a literal 0 still printed its line.
-        if width_raw.isdigit():
+        if width is not None:
             print(f"  Resolution: {width}px", flush=True)
-        if bitrate_raw.isdigit():
+        if bitrate is not None:
             print(f"  Bitrate   : {bitrate // 1_000_000} Mbps", flush=True)
 
-        if score >= 9:
-            success(f"  Plex Score: {score}/10")
-            excellent += 1
-        elif score >= 7:
-            info(f"  Plex Score: {score}/10")
-            good += 1
-        elif score >= 4:
-            note(f"  Plex Score: {score}/10")
-            poor += 1
-        else:
-            warning(f"  Plex Score: {score}/10")
-            bad += 1
+        rated = tier(score)
+        rated.logger(f"  Plex Score: {score}/10")
+        counts[rated.label] += 1
 
         print(f"  Notes     : {notes}", flush=True)
         print(flush=True)
@@ -231,10 +216,8 @@ def main(argv: list[str] | None = None) -> int:
     success("Scan complete")
     print(flush=True)
     print(f"Total Files : {total}", flush=True)
-    print(f"Excellent   : {excellent}", flush=True)
-    print(f"Good        : {good}", flush=True)
-    print(f"Poor        : {poor}", flush=True)
-    print(f"Bad         : {bad}", flush=True)
+    for row in TIERS:
+        print(f"{row.label:<12}: {counts[row.label]}", flush=True)
     return 0
 
 

package/bin/video/fix-codecs.py

@@ -25,14 +25,17 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import CODEC_SCAN_EXTENSIONS
 from utils import (
     add_bool_flag,
     build_parser,
+    dry_run_complete,
     env_bool,
     info,
     iter_files,
     log,
-    note,
+    note_settings,
+    remove_or_warn,
     require_binary,
     run,
     run_cli,
@@ -41,9 +44,7 @@ from utils import (
     warning,
 )
 
-__version__ = "3.0.0"
-
-SCAN_EXTENSIONS = ("mp4", "mkv", "mov", "avi")
+__version__ = "3.1.0"
 
 FFMPEG_ARGS = (
     "-map",
@@ -120,7 +121,6 @@ def main(argv: list[str] | None = None) -> int:
     add_bool_flag(
         parser,
         "--delete-original",
-        dest="delete_original",
         help="Delete each source file after a successful convert",
     )
     add_bool_flag(
@@ -133,25 +133,24 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    if not args.path:
-        warning("Error: You must provide a path with --path=")
-        return 1
-
-    # Binary check before the path check, matching the shell version's order,
-    # so a missing ffmpeg is reported even when the path is also wrong.
+    # Binary check before the directory check, matching the shell version's
+    # order, so a missing ffmpeg is reported even when the path is also wrong.
+    # An empty --path reads "--path is required" after it, where the shell
+    # version said "Error: You must provide a path with --path=" before it.
     require_binary("ffmpeg", hint="Install FFmpeg first.")
 
     root = scan_root(args.path)
 
-    note(f"Scanning: {args.path}")
-    note(f"Delete original after conversion: {str(args.delete_original).lower()}")
-    note(f"Dry run: {str(args.dry_run).lower()}")
-    note("----------------------------------------------------")
+    note_settings(
+        ("Scanning", args.path),
+        ("Delete original after conversion", args.delete_original),
+        ("Dry run", args.dry_run),
+    )
 
     converted = 0
     failed = 0
 
-    for path in iter_files(root, extensions=SCAN_EXTENSIONS):
+    for path in iter_files(root, extensions=CODEC_SCAN_EXTENSIONS):
         # Don't re-encode our own output on a second run. Announced rather than
         # silent, because scene "PROPER/FIXED" repacks legitimately end in
         # _fixed and would otherwise vanish from the listing with no trace.
@@ -161,19 +160,20 @@ def main(argv: list[str] | None = None) -> int:
 
         output = path.with_name(f"{path.stem}_fixed.mp4")
 
-        if args.dry_run:
-            info(f"[DRY RUN] Would re-encode: {path} -> {output}")
-            if args.delete_original:
-                info(f"[DRY RUN] Would delete original: {path}")
-            continue
-
         # Never silently replace an existing conversion; the user may have
         # produced it deliberately, and there is no way to tell it apart from
-        # one this run just made for a different same-stem source.
+        # one this run just made for a different same-stem source. Checked
+        # before the dry-run branch so a preview reports the same skips.
         if output.exists():
             warning(f"⏭️  Skipping (output already exists): {output}")
             continue
 
+        if args.dry_run:
+            info(f"[DRY RUN] Would re-encode: {path} -> {output}")
+            if args.delete_original:
+                info(f"[DRY RUN] Would delete original: {path}")
+            continue
+
         log(f"Processing: {path}")
 
         if not encode(path, output):
@@ -184,16 +184,11 @@ def main(argv: list[str] | None = None) -> int:
         log(f"✅ Converted to: {output}")
         converted += 1
 
-        if args.delete_original:
-            try:
-                path.unlink()
-            except OSError as exc:
-                warning(f"  ✗ Could not delete {path}: {exc}")
-                continue
+        if args.delete_original and remove_or_warn(path):
             warning(f"🗑 Deleted original: {path}")
 
     if args.dry_run:
-        log("💡 Dry run complete. Nothing was actually changed.")
+        dry_run_complete()
         return 0
 
     # Summary and the non-zero exit on failure are both new; the shell version

package/bin/video/largest-tv-shows.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import os
 import re
 import sys
+from collections.abc import Callable
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
@@ -30,12 +31,14 @@ from utils import (
     format_bytes,
     info,
     note,
+    note_settings,
+    parse_count,
     run_cli,
     scan_root,
     warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
 # `^Season[[:space:]]+[0-9]+$` in the shell version. \Z rather than $ because $
 # also matches before a trailing newline, and an explicit [ \t] rather than \s
@@ -43,34 +46,36 @@ __version__ = "3.0.0"
 # otherwise match where the shell version's POSIX classes did not.
 SEASON_RE = re.compile(r"Season[ \t]+[0-9]+\Z")
 
-_NON_NEGATIVE_INT = re.compile(r"[0-9]+")
 
+def _silent(_message: str) -> None:
+    """The ``trace`` used without ``--debug``."""
 
-def is_tv_show_folder(path: Path, *, debug: bool) -> bool:
-    """True when ``path`` has a direct child folder named ``Season <N>``."""
-    if debug:
-        note(f"[DEBUG] Checking folder: {path}")
-    try:
-        for child in path.iterdir():
-            # find -type d does not match a symlink; following one here would
-            # report a show whose season folder lives elsewhere, and then size
-            # it at zero because the walk below refuses to descend.
-            if child.is_symlink() or not child.is_dir():
-                continue
-            if debug:
-                note(f"[DEBUG]   Found child folder: {child.name}")
-            if SEASON_RE.fullmatch(child.name):
-                if debug:
-                    note(f"[DEBUG]   Matched season folder in: {path}")
-                return True
-    except OSError:
-        return False
-    if debug:
-        note(f"[DEBUG]   No season folders found in: {path}")
+
+def is_tv_show_folder(
+    path: Path, child_dirs: list[str], *, trace: Callable[[str], None] = _silent
+) -> bool:
+    """True when one of ``child_dirs``, the folders directly in ``path``, is ``Season <N>``.
+
+    ``child_dirs`` is the listing ``os.walk`` already made, so a folder is
+    read once. Taken in its sorted order, which only shows in ``trace``.
+    """
+    trace(f"[DEBUG] Checking folder: {path}")
+    for name in child_dirs:
+        # os.walk lists a symlinked folder without descending into it. find
+        # -type d does not match a symlink; following one here would report a
+        # show whose season folder lives elsewhere, and then size it at zero
+        # because the walk below refuses to descend.
+        if (path / name).is_symlink():
+            continue
+        trace(f"[DEBUG]   Found child folder: {name}")
+        if SEASON_RE.fullmatch(name):
+            trace(f"[DEBUG]   Matched season folder in: {path}")
+            return True
+    trace(f"[DEBUG]   No season folders found in: {path}")
     return False
 
 
-def folder_size(path: Path, seen: set[tuple[int, int]]) -> int:
+def folder_size(path: Path) -> int:
     """Disk usage under ``path``, matching ``du -sk`` closely enough to rank by.
 
     ``st_blocks * 512`` is ALLOCATED size, which is what ``du`` reports - not
@@ -78,12 +83,13 @@ def folder_size(path: Path, seen: set[tuple[int, int]]) -> int:
     here: a sparse preallocated download reads as its full final size, and a
     library of many small files reads far under its real footprint.
 
-    ``seen`` collects inode identity so a hard-linked file is counted once,
-    again matching ``du``. Sonarr and Radarr hardlink into the library while
-    seeding, so without this a show holding both copies would double. The set
-    is per-show, because the shell version ran one ``du -sk`` per show and each
-    invocation de-duplicates only within its own tree.
+    A hard-linked file is counted once, again matching ``du``. Sonarr and
+    Radarr hardlink into the library while seeding, so without this a show
+    holding both copies would double. The de-duplication is per-show, because
+    the shell version ran one ``du -sk`` per show and each invocation
+    de-duplicates only within its own tree.
     """
+    seen: set[tuple[int, int]] = set()
     total = 0
     for dirpath, _, filenames in os.walk(path, followlinks=False):
         for name in filenames:
@@ -106,36 +112,35 @@ def main(argv: list[str] | None = None) -> int:
         description="📺 Rank TV show folders in a library by total size on disk.",
     )
     parser.add_argument("--path", default="", metavar="DIR", help="TV library root (required)")
-    # Kept as a string so "+5" is rejected the way the shell version's
-    # ^[0-9]+$ test rejected it, rather than silently accepted by int().
+    # Kept as a string and checked by parse_count, so "+5" is rejected the way
+    # the shell version's ^[0-9]+$ test rejected it, not accepted by int().
     parser.add_argument("--limit", default="20", metavar="N", help="How many to list")
-    add_bool_flag(parser, "--full-path", dest="full_path", help="Print the whole path")
+    add_bool_flag(parser, "--full-path", help="Print the whole path")
     add_bool_flag(parser, "--debug", help="Print traversal detail")
 
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    note(f"Searching in: {args.path}")
-    note(f"Limit: {args.limit}")
-    note(f"Show full path: {str(args.full_path).lower()}")
-    note(f"Debug: {str(args.debug).lower()}")
-
-    if not args.path:
-        info(
-            "📋 Usage: largest-tv-shows.py --path=/path/to/tv [--limit=20] [--full-path] [--debug]"
-        )
-        return 1
+    note_settings(
+        ("Searching in", args.path),
+        ("Limit", args.limit),
+        ("Show full path", args.full_path),
+        ("Debug", args.debug),
+        rule=False,
+    )
 
+    # An empty --path reads "--path is required", where the shell version
+    # printed a one-line usage.
     root = scan_root(args.path)
 
-    if not _NON_NEGATIVE_INT.fullmatch(args.limit) or int(args.limit) < 1:
-        warning("Error: --limit must be a positive integer")
-        return 1
-    limit = int(args.limit)
+    # Same test as the shell version's ^[0-9]+$ and -lt 1. The message is the
+    # repo-wide parse_count one, which also echoes the rejected value.
+    limit = parse_count(args.limit, "--limit", minimum=1)
 
     note("Scanning for TV show folders...")
 
-    shows: list[tuple[int, str, Path]] = []
+    trace = note if args.debug else _silent
+    shows: list[tuple[int, Path]] = []
 
     # Nested show folders are listed too (a "Doctor Who Confidential" inside
     # "Doctor Who" is its own row), matching the shell version. Its bytes still
@@ -143,14 +148,12 @@ def main(argv: list[str] | None = None) -> int:
     for dirpath, dirnames, _ in os.walk(root, followlinks=False):
         dirnames.sort()
         directory = Path(dirpath)
-        if args.debug:
-            note(f"[DEBUG] Scanning candidate: {directory}")
-        if not is_tv_show_folder(directory, debug=args.debug):
+        trace(f"[DEBUG] Scanning candidate: {directory}")
+        if not is_tv_show_folder(directory, dirnames, trace=trace):
             continue
-        size = folder_size(directory, set())
-        shows.append((size, directory.name, directory))
-        if args.debug:
-            note(f"[DEBUG] Detected TV show folder: {directory.name} | Size: {size}")
+        size = folder_size(directory)
+        shows.append((size, directory))
+        trace(f"[DEBUG] Detected TV show folder: {directory.name} | Size: {size}")
 
     info(f"Detected {len(shows)} TV show folder(s)")
 
@@ -161,11 +164,11 @@ def main(argv: list[str] | None = None) -> int:
     # `sort -rn` reverses the whole comparison, including its last-resort
     # tiebreak on the full line - so equal-sized shows come out in DESCENDING
     # name order. Reversing both key fields reproduces that.
-    shows.sort(key=lambda item: (item[0], item[1]), reverse=True)
+    shows.sort(key=lambda item: (item[0], item[1].name), reverse=True)
 
     note(f"Top {limit} largest TV show folders:")
-    for size, name, path in shows[:limit]:
-        label = str(path) if args.full_path else name
+    for size, path in shows[:limit]:
+        label = str(path) if args.full_path else path.name
         print(f"{format_bytes(size):<12} {label}", flush=True)
 
     return 0

package/bin/video/remove-metadata.py

@@ -32,7 +32,7 @@ from utils import (
     warning,
 )
 
-__version__ = "2.1.0"
+__version__ = "2.1.1"
 
 DEFAULT_EXTS = (
     "mp4",
@@ -68,11 +68,8 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    if not args.path:
-        warning("❌ --path must be specified")
-        parser.print_help()
-        return 1
-
+    # An empty --path reads "--path is required", where the shell version
+    # printed "--path must be specified" and the full usage.
     root = scan_root(args.path)
 
     require_binary("exiftool", hint="Install exiftool and retry.")