riplex 0.6.4__tar.gz → 0.7.0__tar.gz

{riplex-0.6.4 → riplex-0.7.0}/.gitignore

@@ -10,3 +10,6 @@ build/
 riplex.toml
 plex-planner.toml
 riplex_app.log
+
+# Local dev fixture captures (scripts/capture_fixture.py output)
+_captures/

{riplex-0.6.4 → riplex-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.6.4
+Version: 0.7.0
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.6.4 → riplex-0.7.0}/docs/changelog.md

@@ -1,19 +1,36 @@
-# Documentation Changelog
+# Documentation Changelog
 
 All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
-## 2026-05-13
+## v0.7.0 — 2026-05-16
+
+Summary: organize-time match quality fixes, faster post-rip organize, and a release-picker affordance for verifying the dvdcompare film page.
+
+### Added
+
+- **GUI: "View on dvdcompare.net" link** on the disc-release screen. Shows the auto-selected film page so users can verify region/edition before committing to a long rip.
+- **GUI: manual film-id override** on the disc-release screen. Paste either a bare fid (e.g. `55540`) or a full URL (`https://www.dvdcompare.net/comparisons/film.php?fid=55540`) and riplex fetches and uses that film page instead. The chosen fid is persisted per `(title, disc_format)` so swapping discs in the same box set keeps the override, with a "Clear saved override" affordance.
+- **`riplex organize --rescan`** flag. By default `organize` now reads `_rip_manifest.json` from each disc subfolder when present (instant load, preserves rip-time classification). Pass `--rescan` to force a fresh ffprobe scan instead.
+- **GUI organize folder picker**: when every disc subfolder has a `_rip_manifest.json`, the folder loads instantly without running ffprobe. A green banner indicates the manifest load with a "Rescan with ffprobe" button to force a fresh probe.
+- **GUI organize preview**: every matched row now shows a confidence chip with the actual delta in seconds (e.g. `HIGH ±18s`, `MEDIUM ±104s`) so weak matches are easy to spot before executing.
 
 ### Changed
 
-- Bumped `dvdcompare-scraper` pin to `>=0.1.15`, which adds quoted-title disc-header parsing. Boxsets such as *Back to the Future 40th Anniversary Trilogy* that glue six physical discs into a single dvdcompare disc entry are now split correctly into one PlannedDisc per physical disc.
+- **Tighter match tolerance for extras and episodes.** The global `_MAX_MATCH_DELTA` of 300 s is now reserved for the main-movie target; episodes and extras use a 120 s cap. This prevents short featurettes from being claimed by unrelated short clips when no good candidate exists.
+- **Classification-aware matching.** Files whose rip-time classification is `Unmatched content`, `Unknown content`, or `Very short` are no longer paired with a named extra target unless the duration delta is within ±30 s. Ambiguous shorts stay unmatched (and visible) instead of being silently assigned to the closest dvdcompare entry within the loose 300 s window.
+- **Release workflow**: GitHub Releases now include both the manually composed release notes and the auto-generated commit list, so tag annotations authored ahead of the tag push aren't lost.
 
-### Added
+### Fixed
+
+- **4K disc extras classification**: 1080p extras on a 4K disc are now only skipped when a 4K counterpart actually exists on the same disc. Previously, the duplicate-detection pass could flag legitimate standalone 1080p extras as duplicates of unrelated 4K titles.
+
+## 2026-05-13
+
+### Changed
 
-- Disc Release screen: "View on dvdcompare.net" link showing the auto-selected film page so users can verify region/edition before committing to a long rip.
-- Disc Release screen: manual film-id override input. Paste either a bare fid (e.g. `55540`) or a full URL (`https://www.dvdcompare.net/comparisons/film.php?fid=55540`) and riplex will fetch and use that film page instead. The chosen fid is persisted per `(title, disc_format)` so swapping discs in the same box set keeps the override, with a "Clear saved override" affordance.
+- Bumped `dvdcompare-scraper` pin to `>=0.1.15`, which adds quoted-title disc-header parsing.
 
 ## 2026-05-12
 
@@ -48,7 +65,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 ### Added
 
 - Troubleshooting guide: macOS-specific sections for tkinter/browse button, SSL certificate errors, Gatekeeper blocking, and tools not found despite being installed.
-- Installation guide: new "Install with pipx" section as the recommended install method for end users — provides globally available `riplex` and `riplex-ui` commands without venv activation.
+- Installation guide: new "Install with pipx" section as the recommended install method for end users — provides globally available `riplex` and `riplex-ui` commands without venv activation.
 
 ### Changed
 

{riplex-0.6.4 → riplex-0.7.0}/docs/reference/cli.md

@@ -59,6 +59,7 @@ riplex organize <folder> [options]
 | `--verbose`, `-v` | Print debug logging to stderr (log file is always written) |
 | `--no-cache` | Bypass cached dvdcompare and TMDb responses |
 | `--force` | Re-organize files even if already tagged as organized |
+| `--rescan` | Ignore `_rip_manifest.json` files and re-probe every MKV with ffprobe. By default, riplex reuses rip-time metadata from the manifest when present (faster, preserves classification). |
 | `--json` | Output as JSON |
 | `--api-key` | TMDb API key |
 | `--snapshot` | Replay from a snapshot JSON file instead of scanning live files |

{riplex-0.6.4 → riplex-0.7.0}/src/riplex/disc/analysis.py

@@ -289,22 +289,23 @@ def is_skip_title(
                 return True
 
     # On 4K discs, skip 1080p titles that match non-episode dvdcompare entries
-    # (featurettes, behind-the-scenes, etc. at lower resolution)
-    # Exception: keep 1080p featurette play-alls when no 4K version exists
+    # ONLY when a 4K physical title at the same duration also exists on the
+    # disc (i.e. the 1080p title is a true duplicate). Some studios (e.g.
+    # Universal) ship the 4K main film on a 4K disc but include most extras
+    # at 1080p only — in that case the 1080p extras are the *only* copy and
+    # must be ripped, not skipped.
     if not is_4k and dvd_entries:
         has_4k = any("3840" in (t.resolution or "") for t in all_titles if t.duration_seconds > 600)
         if has_4k:
             match = find_duration_match(dur, dvd_entries)
             if match and match[2] != "episode":
-                # Keep featurette play-alls if no 4K counterpart at same duration
-                if "play all" in match[0].lower() and _is_featurette_play_all(match[2]):
-                    has_4k_version = any(
-                        "3840" in (t.resolution or "") and abs(t.duration_seconds - dur) < 30
-                        for t in all_titles if t is not title
-                    )
-                    if not has_4k_version:
-                        return False
-                return True
+                has_4k_version = any(
+                    "3840" in (t.resolution or "")
+                    and abs(t.duration_seconds - dur) < 30
+                    for t in all_titles if t is not title
+                )
+                if has_4k_version:
+                    return True
 
     # Skip dvdcompare-based play-all if individual episodes exist at same resolution
     if total_episode_runtime > 0 and abs(dur - total_episode_runtime) < 120:

{riplex-0.6.4 → riplex-0.7.0}/src/riplex/matcher.py

@@ -161,8 +161,32 @@ def format_match_report(candidates: list[MatchCandidate]) -> str:
 _FILM_DISC_MARKER = -1
 
 # Absolute maximum delta (seconds) beyond which a pairing is rejected.
-# Prevents garbage matches when no good candidate exists.
-_MAX_MATCH_DELTA = 300
+# The movie target gets a generous tolerance because main-feature
+# runtimes from TMDb are often rounded to the nearest minute and may
+# omit credits / disc-specific intros.  Extras tend to have precise
+# dvdcompare runtimes, so a much tighter cap prevents short featurettes
+# from being matched to unrelated short clips.
+_MAX_MATCH_DELTA = 300         # movie target
+_MAX_MATCH_DELTA_EXTRA = 120   # episodes + extras
+
+# Classification prefixes that signal "rip-time classifier could not
+# identify this title".  When set, the file must not be claimed by a
+# named target unless the delta is very small (< _HIGH_THRESHOLD).
+_UNIDENTIFIED_CLASSIFICATION_PREFIXES = (
+    "Unmatched content",
+    "Unknown content",
+    "Very short",
+)
+
+
+def _is_movie_target(label: str) -> bool:
+    return label.endswith("(movie)")
+
+
+def _is_unidentified(classification: str) -> bool:
+    if not classification:
+        return False
+    return classification.startswith(_UNIDENTIFIED_CLASSIFICATION_PREFIXES)
 
 _PLAY_ALL_RE = re.compile(r"\bplay\s*all\b", re.IGNORECASE)
 
@@ -437,12 +461,30 @@ def match_discs(
     for delta, fi, ti in pairings:
         if fi in claimed_files or ti in claimed_targets:
             continue
-        if delta > _MAX_MATCH_DELTA:
-            log.debug("Stopping greedy claims: delta %ds exceeds max %ds",
-                      delta, _MAX_MATCH_DELTA)
-            break
-        sf = all_scanned[fi]
         label, runtime_s, _t_disc = targets[ti]
+        is_movie = _is_movie_target(label)
+        max_delta = _MAX_MATCH_DELTA if is_movie else _MAX_MATCH_DELTA_EXTRA
+        if delta > max_delta:
+            # Skip — but don't break, since later pairings may involve a
+            # movie target with a looser cap.  Pairings are still sorted
+            # by delta, so any remaining pair this large is also too large.
+            log.debug("Skip pairing: %s -> '%s' delta=%ds exceeds cap %ds",
+                      all_scanned[fi].name, label, delta, max_delta)
+            continue
+        sf = all_scanned[fi]
+        # Honor rip-time classification: if the classifier explicitly
+        # flagged this file as unidentified/short, require a tight delta
+        # before pairing it with a named target.
+        if (
+            not is_movie
+            and _is_unidentified(sf.classification)
+            and delta > _HIGH_THRESHOLD
+        ):
+            log.debug(
+                "Reject pairing on classification: %s [%s] -> '%s' delta=%ds",
+                sf.name, sf.classification, label, delta,
+            )
+            continue
         conf = _confidence(delta)
         log.debug("Claim: %s (%ds) -> '%s' (%ds) delta=%ds [%s]",
                   sf.name, sf.duration_seconds, label, runtime_s, delta, conf)

{riplex-0.6.4 → riplex-0.7.0}/src/riplex/organizer.py

@@ -75,6 +75,7 @@ class FileMove:
     destination: str
     label: str  # what this file was matched to
     confidence: str
+    delta_seconds: int = 0  # |file_runtime - target_runtime|, for diagnostics
 
 
 @dataclass
@@ -86,6 +87,7 @@ class SplitMove:
     chapter_labels: list[str]  # one label per chapter
     confidence: str
     original_label: str = ""  # the dvdcompare match label
+    delta_seconds: int = 0
 
 
 @dataclass
@@ -396,6 +398,7 @@ def build_organize_plan(
                 destination=str(dest),
                 label=candidate.matched_label,
                 confidence=candidate.confidence,
+                delta_seconds=candidate.delta_seconds,
             )
         )
 

{riplex-0.6.4 → riplex-0.7.0}/src/riplex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.6.4
+Version: 0.7.0
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11

{riplex-0.6.4 → riplex-0.7.0}/src/riplex_app/screens/folder_picker.py

@@ -11,6 +11,7 @@ log = logging.getLogger(__name__)
 
 from riplex.config import get_rip_output
 from riplex.detect import detect_format
+from riplex.manifest import build_scanned_from_manifests
 from riplex.scanner import scan_folder
 from riplex.snapshot import load_organized_marker
 from riplex.title import infer_title_from_scanned
@@ -124,8 +125,48 @@ class FolderPickerScreen:
             return
         self.folder_field.error_text = None
 
-        self.app.state["source_folder"] = Path(path)
+        folder = Path(path)
+        self.app.state["source_folder"] = folder
 
+        # Fast path: if every disc subfolder has a _rip_manifest.json,
+        # load metadata from the manifest instead of running ffprobe.
+        if self._has_complete_manifests(folder):
+            log.info("loading scan from rip manifests in %s", folder)
+            try:
+                scanned = build_scanned_from_manifests(folder)
+            except Exception as exc:
+                log.exception("manifest load failed; falling back to ffprobe")
+                scanned = None
+            if scanned:
+                self.app.state["_scan_from_manifest"] = True
+                self.app.state["_scan_result"] = scanned
+                self.app.navigate("folder_picker")
+                return
+
+        self.app.state["_scan_from_manifest"] = False
+        self._start_ffprobe_scan(folder)
+
+    def _has_complete_manifests(self, folder: Path) -> bool:
+        subfolders_with_mkvs = [
+            c for c in folder.iterdir()
+            if c.is_dir() and any(c.glob("*.mkv"))
+        ]
+        if not subfolders_with_mkvs:
+            return False
+        return all((c / "_rip_manifest.json").exists() for c in subfolders_with_mkvs)
+
+    def _rescan_with_ffprobe(self, e):
+        """User clicked the 'Rescan with ffprobe' banner button."""
+        folder = self.app.state.get("source_folder")
+        if not folder:
+            return
+        # Clear any cached scan and force a fresh ffprobe scan.
+        self.app.state.pop("scanned", None)
+        self.app.state.pop("_scan_result", None)
+        self.app.state["_scan_from_manifest"] = False
+        self._start_ffprobe_scan(folder)
+
+    def _start_ffprobe_scan(self, folder: Path):
         # Show scanning state with progress
         self._progress_text = ft.Text("Discovering files...", size=14)
         self._progress_bar = ft.ProgressBar(width=400)
@@ -149,7 +190,7 @@ class FolderPickerScreen:
         )
         self.app.page.update()
 
-        threading.Thread(target=self._do_scan, args=(Path(path),), daemon=True).start()
+        threading.Thread(target=self._do_scan, args=(folder,), daemon=True).start()
 
     def _do_scan(self, folder: Path):
         """Run ffprobe scan in background."""
@@ -219,6 +260,31 @@ class FolderPickerScreen:
                 ),
             ]
 
+        # Banner shown when the scan came from rip manifests (instant load).
+        manifest_banner = []
+        if self.app.state.get("_scan_from_manifest"):
+            manifest_banner = [
+                ft.Container(
+                    content=ft.Row([
+                        ft.Icon(ft.Icons.BOLT, color=ft.Colors.GREEN_400, size=18),
+                        ft.Text(
+                            "Loaded instantly from rip manifests (no ffprobe needed).",
+                            size=13,
+                            color=ft.Colors.GREEN_400,
+                            expand=True,
+                        ),
+                        ft.TextButton(
+                            "Rescan with ffprobe",
+                            icon=ft.Icons.REFRESH,
+                            on_click=self._rescan_with_ffprobe,
+                        ),
+                    ], spacing=8),
+                    bgcolor=ft.Colors.with_opacity(0.08, ft.Colors.GREEN),
+                    padding=12,
+                    border_radius=8,
+                ),
+            ]
+
         # Build disc summary rows
         disc_rows = []
         for d in scanned:
@@ -252,6 +318,7 @@ class FolderPickerScreen:
                     color=ft.Colors.GREY_500,
                 ),
                 ft.Divider(height=20),
+                *manifest_banner,
                 *marker_banner,
                 ft.Text(
                     f"Scanned {len(scanned)} disc{'s' if len(scanned) != 1 else ''}, "

{riplex-0.6.4 → riplex-0.7.0}/src/riplex_app/screens/organize_preview.py

@@ -175,10 +175,25 @@ class OrganizePreviewScreen:
                 "medium": ft.Colors.YELLOW,
                 "low": ft.Colors.ORANGE,
             }.get(move.confidence, ft.Colors.GREY)
+            # Confidence chip: shows label + delta so the user can spot
+            # weak (medium/low) matches before executing.
+            delta = getattr(move, "delta_seconds", 0)
+            conf_label = (move.confidence or "?").upper()
+            if delta:
+                conf_text = f"{conf_label} \u00B1{delta}s"
+            else:
+                conf_text = conf_label
+            conf_chip = ft.Container(
+                content=ft.Text(conf_text, size=10, color=conf_color, weight=ft.FontWeight.BOLD),
+                bgcolor=ft.Colors.with_opacity(0.12, conf_color),
+                padding=ft.Padding(left=6, right=6, top=2, bottom=2),
+                border_radius=4,
+            )
             move_rows.append(
                 ft.Row([
                     ft.Icon(ft.Icons.CHECK_CIRCLE, color=conf_color, size=16),
-                    ft.Text(f"{src_name}", size=12, width=250, no_wrap=True),
+                    conf_chip,
+                    ft.Text(f"{src_name}", size=12, width=220, no_wrap=True),
                     ft.Icon(ft.Icons.ARROW_FORWARD, size=14, color=ft.Colors.GREY_500),
                     ft.Text(f"{dest_folder}/{dest_name}", size=12, expand=True, no_wrap=True),
                 ], spacing=6)

{riplex-0.6.4 → riplex-0.7.0}/src/riplex_app/screens/release.py

@@ -41,6 +41,39 @@ class ReleaseScreen:
             return tmdb_match.title
         return self.app.state["title"]
 
+    # -- manual film-id override (cache-backed) ---------------------------
+
+    def _override_cache_key(self) -> str:
+        """Stable key for caching the user's manual film-id pick.
+
+        Keyed by ``(title, disc_format)`` so that swapping discs within the
+        same physical box set still picks up the override, but ripping a
+        different format edition (DVD vs 4K) of the same film does not.
+        """
+        title = self._current_search_title()
+        fmt = self._detect_disc_format() or ""
+        return _cache.hash_key(f"{title}|{fmt}")
+
+    def _load_persisted_override(self) -> int | None:
+        entry = _cache.cache_get(_OVERRIDE_CACHE_NS, self._override_cache_key(), ttl_days=365)
+        if isinstance(entry, dict):
+            fid = entry.get("film_id")
+            if isinstance(fid, int):
+                return fid
+        return None
+
+    def _save_persisted_override(self, film_id: int) -> None:
+        _cache.cache_set(
+            _OVERRIDE_CACHE_NS,
+            self._override_cache_key(),
+            {"film_id": film_id},
+        )
+
+    def _clear_persisted_override(self) -> None:
+        # cache module has no delete; write a sentinel that won't pass the
+        # int check in _load_persisted_override.
+        _cache.cache_set(_OVERRIDE_CACHE_NS, self._override_cache_key(), {"film_id": None})
+
     def _build_search_bar(self, title: str, *, searching: bool) -> ft.Control:
         """Editable dvdcompare search field."""
         self._search_field = ft.TextField(

{riplex-0.6.4 → riplex-0.7.0}/src/riplex_cli/commands/organize.py

@@ -11,6 +11,7 @@ from riplex.config import get_api_key, get_archive_root, get_output_root
 from riplex.dedup import find_all_redundant, remove_duplicates
 from riplex.detect import detect_format, detect_incomplete, group_title_folders, infer_media_type_from_files
 from riplex.lookup import lookup_metadata
+from riplex.manifest import build_scanned_from_manifests
 from riplex.matcher import (
     collect_disc_targets,
     map_folders_to_discs,
@@ -41,6 +42,38 @@ from riplex_cli.formatting import (
 log = logging.getLogger(__name__)
 
 
+def _has_complete_manifests(folder: Path) -> bool:
+    """Return True if every direct subfolder containing MKVs also has a
+    ``_rip_manifest.json`` (i.e. the folder was produced by ``riplex rip``).
+    """
+    subfolders_with_mkvs = [
+        c for c in folder.iterdir()
+        if c.is_dir() and any(c.glob("*.mkv"))
+    ]
+    if not subfolders_with_mkvs:
+        return False
+    return all((c / "_rip_manifest.json").exists() for c in subfolders_with_mkvs)
+
+
+def _load_scanned(folder: Path, args: argparse.Namespace) -> list:
+    """Load ScannedDisc list, preferring rip manifests when present.
+
+    Re-probes via ffprobe when ``--rescan`` is set or when manifests are
+    missing/incomplete.
+    """
+    if not getattr(args, "rescan", False) and _has_complete_manifests(folder):
+        print(
+            f"Loading rip manifests from {folder} (use --rescan to force ffprobe).",
+            file=sys.stderr,
+        )
+        scanned = build_scanned_from_manifests(folder)
+        if scanned:
+            return scanned
+        print("Manifests found but no usable entries; falling back to ffprobe scan.", file=sys.stderr)
+    print(f"Scanning {folder} ...", file=sys.stderr)
+    return scan_folder(folder)
+
+
 async def run_organize(args: argparse.Namespace) -> int:
     """Run the organize workflow: scan, look up metadata, match, organize."""
     log_file = setup_logging(verbose=getattr(args, "verbose", False))
@@ -203,9 +236,8 @@ async def _organize_multi_folder(
 
     all_scanned: list[ScannedDisc] = []
     for folder in folders:
-        print(f"Scanning {folder} ...", file=sys.stderr)
         try:
-            scanned = scan_folder(folder)
+            scanned = _load_scanned(folder, args)
             snapshot_out = folder / f"{folder.name}.snapshot.json"
             if not snapshot_out.exists():
                 snapshot_save_from_scanned(folder, scanned, snapshot_out)
@@ -244,9 +276,8 @@ async def _organize_single(
             )
             return 0
 
-    print(f"Scanning {folder} ...", file=sys.stderr)
     try:
-        scanned = scan_folder(folder)
+        scanned = _load_scanned(folder, args)
     except RuntimeError as exc:
         print(f"Error: {exc}", file=sys.stderr)
         return 1

{riplex-0.6.4 → riplex-0.7.0}/src/riplex_cli/main.py

@@ -110,6 +110,16 @@ def _build_parser() -> argparse.ArgumentParser:
         default=False,
         help="Skip interactive prompts, use best-guess defaults.",
     )
+    org_parser.add_argument(
+        "--rescan",
+        action="store_true",
+        default=False,
+        help=(
+            "Ignore _rip_manifest.json files and re-probe every MKV with "
+            "ffprobe.  By default, riplex reuses rip-time metadata from "
+            "the manifest when present (faster, preserves classification)."
+        ),
+    )
 
     # --- lookup ---
     guide_parser = subs.add_parser(

{riplex-0.6.4 → riplex-0.7.0}/tests/fixtures/chernobyl_disc1.json

@@ -65,8 +65,8 @@
     "is_movie": false,
     "movie_runtime": null,
     "disc_number": 1,
-    "rip_indices": [0, 1, 2, 3, 4],
-    "skip_indices": [5, 6, 7, 8, 9, 10, 11, 12],
+    "rip_indices": [0, 1, 2, 3, 4, 10, 11, 12],
+    "skip_indices": [5, 6, 7, 8, 9],
     "episode_names": {
       "0": "1:23:45",
       "3": "Open Wide, O Earth",

{riplex-0.6.4 → riplex-0.7.0}/tests/test_disc_analysis.py

@@ -237,6 +237,43 @@ class TestIsSkipTitle:
             False, None, 0, 0, dvd_entries,
         ) is False
 
+    def test_keep_1080p_extra_on_4k_disc_without_4k_counterpart(self):
+        """On a 4K disc with 1080p-only extras (Universal BttF 40th Anniversary
+        pattern), the 1080p extras should NOT be skipped just because a 4K
+        main film exists on the same disc. They're the only copy."""
+        # 4K main film (movie length) so the disc qualifies as "has_4k"
+        main_4k = _make_title(0, 7098, resolution="3840x2160")
+        # 1080p featurette with a dvdcompare entry but NO 4K counterpart
+        feat_1080 = _make_title(1, 1027, resolution="1920x1080")
+        dvd_entries = [
+            ("Tales from the Future: Third Time's the Charm", 1027, "featurette"),
+        ]
+        assert is_skip_title(
+            feat_1080, [main_4k, feat_1080],
+            True, 7098, 0, 0, dvd_entries,
+        ) is False
+
+    def test_skip_1080p_extra_when_4k_counterpart_exists(self):
+        """When the same extra exists in both 4K and 1080p on the disc
+        (true duplicate), keep the 4K version and skip the 1080p."""
+        main_4k = _make_title(0, 7098, resolution="3840x2160")
+        # Same featurette, both resolutions, same duration
+        feat_4k = _make_title(1, 248, resolution="3840x2160")
+        feat_1080 = _make_title(2, 248, resolution="1920x1080")
+        dvd_entries = [
+            ("Music Video by ZZ Top: Doubleback", 248, "extra"),
+        ]
+        # 1080p version should be skipped (4K duplicate exists)
+        assert is_skip_title(
+            feat_1080, [main_4k, feat_4k, feat_1080],
+            True, 7098, 0, 0, dvd_entries,
+        ) is True
+        # 4K version should be kept
+        assert is_skip_title(
+            feat_4k, [main_4k, feat_4k, feat_1080],
+            True, 7098, 0, 0, dvd_entries,
+        ) is False
+
 
 class TestBuildDvdEntries:
     def test_builds_entries(self):

{riplex-0.6.4 → riplex-0.7.0}/tests/test_disc_fixtures.py

@@ -216,7 +216,8 @@ class TestChernobylDisc1:
             )
 
     def test_1080p_skipped_when_4k_exists(self, disc_data):
-        """1080p titles should be skipped when 4K versions exist."""
+        """1080p titles should be skipped only when a 4K version exists on
+        the same disc. 1080p-only extras (no 4K counterpart) must be kept."""
         disc_info, planned_discs, expected = disc_data
 
         analysis = analyze_disc(
@@ -227,9 +228,15 @@ class TestChernobylDisc1:
         )
 
         rip_indices = [t.index for t in analysis.rippable_titles]
-        # #5 (1080p version of #1) and #10, #11, #12 (1080p featurettes)
-        # should not be in rip list
-        for idx in [5, 10, 11, 12]:
-            assert idx not in rip_indices, (
-                f"Title #{idx} (1080p) should be skipped: {analysis.classifications[idx]}"
+        # #5 (1080p version of #1, 4K counterpart exists) should be skipped.
+        # #10, #11, #12 (1080p featurette children with no 4K counterpart)
+        # must NOT be skipped — they're the only copy of that content.
+        assert 5 not in rip_indices, (
+            f"Title #5 (1080p dup of 4K #1) should be skipped: "
+            f"{analysis.classifications[5]}"
+        )
+        for idx in [10, 11, 12]:
+            assert idx in rip_indices, (
+                f"Title #{idx} (1080p featurette with no 4K counterpart) "
+                f"should NOT be skipped: {analysis.classifications[idx]}"
             )

{riplex-0.6.4 → riplex-0.7.0}/tests/test_matcher.py

@@ -542,7 +542,9 @@ class TestMaxDeltaThreshold:
         assert len(result.unmatched) == 1
 
     def test_within_threshold_still_matches(self):
-        """A file 200s away from the target still matches (under 300s)."""
+        """A file 100s away from the target still matches (under the
+        extra cap of 120s).
+        """
         discs = [
             PlannedDisc(
                 number=1,
@@ -556,13 +558,65 @@ class TestMaxDeltaThreshold:
             ScannedDisc(
                 folder_name="Disc 1",
                 files=[
-                    ScannedFile(name="a.mkv", path="x", duration_seconds=3200),
+                    ScannedFile(name="a.mkv", path="x", duration_seconds=3100),
                 ],
             ),
         ]
         result = match_discs(scanned, discs)
         assert len(result.matched) == 1
-        assert result.matched[0].confidence == "low"
+        assert result.matched[0].confidence == "medium"
+
+    def test_movie_target_still_uses_300s_cap(self):
+        """The main-movie target keeps the generous 300s cap so TMDb
+        runtimes rounded to the nearest minute still match.
+        """
+        from riplex.models import PlannedMovie
+
+        plan = PlannedMovie(
+            canonical_title="Foo", year=2020,
+            runtime="120m", runtime_seconds=7200,
+        )
+        discs = [PlannedDisc(number=1, disc_format="Blu-ray", is_film=True)]
+        scanned = [
+            ScannedDisc(
+                folder_name="Disc 1",
+                files=[
+                    ScannedFile(name="film.mkv", path="x", duration_seconds=7450),
+                ],
+            ),
+        ]
+        result = match_discs(scanned, discs, plan)
+        assert len(result.matched) == 1
+        assert "(movie)" in result.matched[0].matched_label
+
+    def test_extra_with_unidentified_classification_rejected(self):
+        """A file the rip-time classifier flagged as 'Unmatched content'
+        must not be paired with a named extra target unless the delta
+        is very small.
+        """
+        discs = [
+            PlannedDisc(
+                number=1,
+                disc_format="Blu-ray",
+                extras=[
+                    PlannedExtra(title="Hoverboard Commercial", runtime_seconds=66),
+                ],
+            ),
+        ]
+        scanned = [
+            ScannedDisc(
+                folder_name="Disc 1",
+                files=[
+                    ScannedFile(
+                        name="t14.mkv", path="x", duration_seconds=170,
+                        classification="Unmatched content (4K, 2:50)",
+                    ),
+                ],
+            ),
+        ]
+        result = match_discs(scanned, discs)
+        assert len(result.matched) == 0
+        assert len(result.unmatched) == 1
 
     def test_blue_planet_ii_scenario(self):
         """INTO THE BLUE files rejected by max delta and play-all filter."""