riplex 0.9.4__tar.gz → 0.9.6__tar.gz

{riplex-0.9.4 → riplex-0.9.6}/.github/agents/riplex.agent.md

@@ -21,55 +21,84 @@ riplex eliminates the manual work after MakeMKV dumps raw MKV files from a physi
 ```
 src/
   riplex/              # Shared library (all business logic)
-    cli.py             # Backward-compatible shim (re-exports from riplex_cli.main)
-    config.py          # Config loading (~/.config/riplex/config.toml or platform equivalent)
+    config.py          # Config loading (platform config dir via platformdirs)
     models.py          # Data models (ScannedFile, PlannedDisc, PlannedMovie, PlannedShow, etc.)
-    orchestrate.py     # Shared pipeline logic reusable by CLI and GUI
-    metadata_provider.py  # Abstract metadata provider interface
-    metadata_sources/
-      tmdb.py          # TMDb API implementation
-    disc_provider.py   # dvdcompare.net bridge (lookup_discs, find_film, _convert_release)
-    disc_analysis.py   # Live disc title classification (classify_title, is_skip_title, build_dvd_entries)
-    makemkv.py         # makemkvcon wrapper (drive scanning, disc reading, ripping, progress parsing)
-    scanner.py         # MKV folder scanner (ffprobe metadata extraction)
+    lookup.py          # Shared lookup pipeline logic reusable by CLI and GUI
+    scanner.py         # MKV folder scanner (ffprobe metadata extraction; find_ffprobe tool detection)
     matcher.py         # Runtime-based file-to-entry matching with disc constraints
     organizer.py       # Plex destination path builder and file mover
-    planner.py         # TMDb metadata planning (builds PlannedMovie/PlannedShow)
     detect.py          # Format auto-detection, title grouping, incomplete file detection
     dedup.py           # Duplicate MKV detection (metadata fingerprint + perceptual hash)
     splitter.py        # Chapter-based MKV splitting via mkvmerge
     tagger.py          # MKV tagging (marks files as organized via mkvpropedit)
+    manifest.py        # Disc manifest / debug artifact handling
     cache.py           # File-based JSON cache with TTL
     normalize.py       # Title normalization
+    title.py           # Title model / parsing helpers
     formatter.py       # Text and JSON output formatting
-    snapshot.py        # Scan result serialization
+    snapshot.py        # Scan result serialization (offline replay)
+    updater.py         # App self-update version check
     ui.py              # Interactive prompts (prompt_choice, prompt_confirm, prompt_text, prompt_multi_select)
+    disc/              # Live disc subpackage
+      analysis.py      # Title classification (classify_title, is_skip_title, build_dvd_entries)
+      makemkv.py       # makemkvcon wrapper (drive scanning, disc reading, ripping, progress parsing)
+      provider.py      # dvdcompare.net bridge (lookup_discs, find_film, _convert_release)
+    metadata/          # Metadata subpackage
+      planner.py       # TMDb metadata planning (builds PlannedMovie/PlannedShow)
+      provider.py      # Abstract metadata provider interface
+      sources/
+        tmdb.py        # TMDb API implementation
   riplex_cli/          # CLI thin wrapper (argparse, command dispatch, terminal formatting)
-    main.py            # Full CLI implementation, entry point: main()
+    main.py            # Argparse setup + command dispatch, entry point: main()
+    formatting.py      # Terminal output formatting helpers
+    commands/          # One module per subcommand
+      orchestrate.py   # Full pipeline command
+      rip.py           # Single-disc rip command
+      organize.py      # Organize existing MKV folder command
+      lookup.py        # Preview disc contents command
+      setup.py         # Interactive config wizard command
   riplex_app/          # Flet GUI (wizard-style screens)
     main.py            # App entry point, screen navigation controller
+    bug_report.py      # Bug report bundling helper
+    crash_dump.py      # Crash dump capture
+    keep_awake.py      # Prevent system sleep during long rips
     screens/
-      welcome.py       # Config and tool verification
-      disc_detection.py  # Drive scanning, disc reading
-      metadata.py      # TMDb search and selection
-      release.py       # dvdcompare release picker
-      selection.py     # Title selection with classify_title
-      progress.py      # Rip progress with makemkvcon
-      done.py          # Results summary
+      welcome.py           # Config and tool verification
+      disc_detection.py    # Drive scanning, disc reading
+      disc_overview.py     # Multi-disc overview
+      disc_swap.py         # Disc swap prompt (multi-disc sets)
+      metadata.py          # TMDb search and selection
+      release.py           # dvdcompare release picker
+      selection.py         # Title selection with classify_title
+      progress.py          # Rip progress with makemkvcon
+      organize_preview.py  # Organize plan preview
+      organize_done.py     # Organize results summary
+      orchestrate_done.py  # Orchestrate results summary
+      done.py              # Rip results summary
+      update.py            # Self-update screen
+      folder_picker.py     # Folder browse dialog (tkinter)
 tests/
-  fixtures/            # makemkvcon output samples for parsing tests
+  fixtures/            # makemkvcon output samples + disc JSON fixtures
   snapshots/           # Serialized disc scan results for offline replay
   test_*.py            # One test file per module (test_matcher.py, test_disc_analysis.py, etc.)
 docs/
   architecture.md      # System design, data flow diagrams
   naming-rules.md      # Plex naming conventions
   changelog.md         # Documentation changelog (Keep a Changelog format)
+  troubleshooting.md   # Common problems and fixes
+  index.md             # Docs landing page
   getting-started/     # Installation, configuration
-  gui-guide/           # Desktop app walkthroughs
+  gui-guide/           # Desktop app walkthrough
   cli-guide/           # Command-by-command workflow guides
   reference/           # CLI reference
 ```
 
+Note: business logic lives in the `riplex` library. `riplex/disc/` and
+`riplex/metadata/` are proper subpackages (not flat `disc_analysis.py` /
+`metadata_sources/`). The CLI's per-command logic lives in
+`riplex_cli/commands/`. There is no `src/riplex/cli.py` or
+`src/riplex/orchestrate.py`.
+
 ## Commands
 
 | Command | Purpose |
@@ -110,8 +139,14 @@ Do NOT use `py -m riplex` (errors — riplex is a library package). Do NOT use `
 
 - Python 3.11+ (use `py` command, never `python` or `python3`)
 - Async: httpx for HTTP, asyncio.run() from sync CLI entry points
-- Dependencies: httpx, dvdcompare-scraper, platformdirs
-- GUI: Flet 0.84+ (optional `[gui]` extra)
+- Dependencies: certifi, httpx, dvdcompare-scraper, platformdirs
+- GUI: Flet, pinned to `flet==0.85.1` in the `[gui]` extra. The pin is
+  intentional: the macOS desktop runtime in 0.85.3 ships a malformed nested
+  `objective_c.framework` that newer `codesign` rejects, which broke the macOS
+  release build and crashed the packaged GUI on launch (issue #21). Keep
+  `flet` and `flet-desktop` in lockstep at the same version.
+- Versioning: `setuptools-scm` derives the version from the latest `v*` git
+  tag (no hardcoded version in `pyproject.toml`).
 - External tools: makemkvcon, ffprobe, mkvmerge, mkvpropedit
 
 ## Debugging the GUI
@@ -167,12 +202,6 @@ Docs live in `docs/` and are referenced from README.md.
 - `docs/cli-guide/`: Command-by-command workflow walkthroughs
 - `docs/reference/cli.md`: Complete CLI option reference
 
-*** Delete File: c:\Users\asher\Projects\anycredit5518\riplex\docs\guide\gui-walkthrough.md
-*** Delete File: c:\Users\asher\Projects\anycredit5518\riplex\docs\guide\workflow.md
-*** Delete File: c:\Users\asher\Projects\anycredit5518\riplex\docs\guide\orchestrate.md
-*** Delete File: c:\Users\asher\Projects\anycredit5518\riplex\docs\guide\lookup.md
-*** Delete File: c:\Users\asher\Projects\anycredit5518\riplex\docs\guide\organize.md
-
 ### Documentation rules
 
 - When making significant changes (new features, renamed modules, changed behavior), update the relevant docs
@@ -197,11 +226,52 @@ Docs live in `docs/` and are referenced from README.md.
 - Dry-run by default: never move or delete files without explicit `--execute`
 - Config is shared between CLI and GUI (`~/.config/riplex/config.toml` or platform equivalent)
 
-## Current active work
-
-The monorepo refactor is complete. The repo contains three source packages:
+## Release workflow
+
+Releases are built by `.github/workflows/release.yml`.
+
+- Triggers: `push` of a `v*` tag, and manual `workflow_dispatch`.
+- Jobs: `build-windows` (windows-latest), `build-macos` (macos-14, arm64),
+  and `release` (ubuntu-latest).
+- The `release` job is gated on `if: startsWith(github.ref, 'refs/tags/v')`.
+  So a `workflow_dispatch` run on a branch or `main` runs ONLY the build jobs
+  and uploads artifacts — it does NOT create a user-facing release. This is
+  the safe way to validate packaging changes before tagging.
+- To cut a real release: push an annotated `v*` tag on `main`. The tag
+  annotation becomes the release header; `setuptools-scm` picks up the
+  version from the tag.
+- macOS GUI packaging: do NOT pass Flet's extracted `Flet.app` runtime to
+  PyInstaller. PyInstaller force-signs collected binaries on arm64 and
+  `codesign` rejects Flet's nested frameworks. Instead the workflow downloads
+  Flet's upstream `flet-macos.tar.gz` and bundles it under
+  `flet_desktop/app`; `flet_desktop.ensure_client_cached()` extracts it at
+  runtime. The macOS `.app` zip uses `zip -y` to preserve framework symlinks
+  (flattened symlinks crash the app on launch).
+- Debugging CI: `gh run view <id> --json status,conclusion,jobs`; for logs of
+  a still-running run, fetch a finished job directly with
+  `gh api repos/<owner>/<repo>/actions/jobs/<jobId>/logs`
+  (the `--log`/`--log-failed` flags refuse until the whole run completes).
+
+## Dependency and packaging cautions
+
+- A Flet runtime regression can surface as a riplex GUI launch crash even
+  when riplex's own code is unchanged — check the Flet/PyInstaller packaging
+  path before assuming an app-code bug.
+- `tkinter` (used by the GUI folder picker) is an OS-level dependency, not a
+  pip package: macOS Homebrew Python needs `brew install python-tk@3.12`.
+- On Windows, close `riplex-ui` before upgrading deps — the entry-point
+  `.exe` shim is locked while the process runs and pip fails with `WinError 32`.
+
+## Issue workflow
+
+- When fixing a GitHub issue, reference it in the commit and/or tag message.
+- After a tagged release ships, draft a user-facing comment that leads with
+  the reported symptom, gives a high-level cause and the fixed version, and
+  asks the reporter to retry (and reopen if still broken) before closing.
+
+## Source packages
+
+The repo contains three source packages:
 - `riplex` — shared library (all business logic)
 - `riplex_cli` — CLI thin wrapper
 - `riplex_app` — Flet GUI
-
-See `MONOREPO_PLAN.md` for background on the refactor.

{riplex-0.9.4 → riplex-0.9.6}/.github/copilot-instructions.md

@@ -105,3 +105,31 @@ All destructive commands (`rip`, `organize`, `orchestrate`) are dry-run by defau
 ## Testing
 
 Run tests with `pytest` (or `python -m pytest`) from the project root with the venv active. All tests must pass before committing.
+
+## Debugging the GUI
+
+The GUI writes detailed logs to `riplex_app.log` in the working directory
+(project root when launched from the repo). Check this file first when
+debugging GUI behavior. Do NOT try to capture the GUI's terminal output with
+a `2>&1` redirect — it breaks Flet's Flutter-Python IPC.
+
+## Releases and packaging
+
+Releases are produced by `.github/workflows/release.yml`.
+
+- A GitHub Release is created ONLY when a `v*` tag is pushed. The `release`
+  job is gated on `refs/tags/v*`.
+- `workflow_dispatch` on a branch or `main` runs only the build jobs and
+  uploads artifacts without publishing — use it to validate packaging changes
+  before tagging.
+- To release: push an annotated `v*` tag on `main`. `setuptools-scm` derives
+  the version from that tag (there is no version string in `pyproject.toml`).
+- macOS builds run on `macos-14` (arm64). The macOS GUI bundles Flet's
+  upstream `flet-macos.tar.gz` runtime archive (extracted at runtime) rather
+  than feeding the extracted `Flet.app` to PyInstaller, and zips the `.app`
+  with `zip -y` to preserve framework symlinks. Do not revert these without
+  understanding issue #21.
+- Keep `flet` and `flet-desktop` pinned to the same version. A Flet runtime
+  regression can present as a GUI launch crash even when riplex's own code is
+  unchanged.
+

{riplex-0.9.4/src/riplex.egg-info → riplex-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.9.4
+Version: 0.9.6
 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.9.4 → riplex-0.9.6}/src/riplex/disc/provider.py

@@ -872,10 +872,16 @@ def detect_disc_number(
 ) -> int | None:
     """Auto-detect which dvdcompare disc number the physical disc corresponds to.
 
-    Tries three strategies:
+    Tries three strategies in order:
     1. Parse the volume label for a disc number (e.g. "FROZEN_PLANET_II_D2" -> 2)
-    2. Match live title durations against each dvdcompare disc's episodes and extras.
-    3. For movies, match by disc format/resolution.
+    2. For multi-format releases, match by disc format/resolution (4K vs Blu-ray).
+    3. Match live title durations against each dvdcompare disc's episodes and extras.
+
+    Strategy 2 runs before duration matching because a movie released across
+    several format discs (4K + Blu-ray + 3D) carries the *same* main feature on
+    every disc, so its runtime cannot distinguish them — and duration matching
+    can actively pick the wrong disc when one disc lacks listed runtimes. The
+    resolution is the only reliable distinguishing signal in that case.
 
     Returns the disc number (1-based) or None if detection fails.
     """
@@ -885,7 +891,13 @@ def detect_disc_number(
     if match:
         return int(match.group(1))
 
-    # Strategy 2: duration matching against dvdcompare discs
+    # Strategy 2: format/resolution match (authoritative for multi-format
+    # movie releases, where every disc shares the same main feature runtime).
+    format_disc = _match_disc_by_format(disc_info, dvdcompare_discs)
+    if format_disc is not None:
+        return format_disc
+
+    # Strategy 3: duration matching against dvdcompare discs
     if not dvdcompare_discs or not disc_info.titles:
         return None
 
@@ -936,7 +948,20 @@ def detect_disc_number(
     if best_score >= 0.5:
         return best_disc
 
-    # Strategy 3: for movies, match by disc format/resolution
+    return None
+
+
+def _match_disc_by_format(disc_info, dvdcompare_discs: list) -> int | None:
+    """Match the live disc to a dvdcompare disc by format/resolution.
+
+    Only returns a result when exactly one disc matches the live disc's
+    resolution, i.e. when the format is genuinely distinguishing (e.g. a single
+    4K disc among standard Blu-rays). Same-format multi-disc sets (TV box sets)
+    yield multiple candidates and fall through to duration matching.
+    """
+    if not dvdcompare_discs:
+        return None
+
     live_resolutions = {t.resolution for t in disc_info.titles if t.resolution}
     has_4k = any("2160" in r for r in live_resolutions)
     has_1080 = any("1080" in r for r in live_resolutions)
@@ -955,6 +980,7 @@ def detect_disc_number(
     return None
 
 
+
 # ---------------------------------------------------------------------------
 # Disc content summary
 # ---------------------------------------------------------------------------

{riplex-0.9.4 → riplex-0.9.6}/src/riplex/metadata/sources/tmdb.py

@@ -10,6 +10,7 @@ or passed directly to the constructor.
 from __future__ import annotations
 
 import os
+import re
 from typing import Literal
 
 import httpx
@@ -28,6 +29,47 @@ TMDB_BASE_URL = "https://api.themoviedb.org/3"
 _TMDB_TTL_DAYS = 7
 
 
+def _normalize_for_match(text: str) -> str:
+    """Lowercase *text* and collapse runs of non-alphanumerics to spaces.
+
+    This makes punctuation-insensitive comparisons possible so that, e.g.,
+    ``"TRON: Legacy"`` and ``"Tron Legacy"`` compare equal.
+    """
+    return re.sub(r"[^a-z0-9]+", " ", text.lower()).strip()
+
+
+def _title_match_tier(query: str, title: str) -> int:
+    """Rank how well *title* matches the search *query* (higher is better).
+
+    TMDb's ``/search/movie`` and ``/search/tv`` endpoints return loosely
+    fuzzy matches: a search for ``"Tron"`` surfaces wildly popular but
+    unrelated shows like ``House of the Dragon``. Sorting the merged list by
+    raw popularity therefore buries the title the user actually searched for.
+    This tier ranks literal title overlap ahead of popularity so genuine
+    matches win, with popularity only breaking ties within a tier.
+
+    Tiers (high to low):
+      4 - exact title match
+      3 - title starts with the query (e.g. ``"TRON: Legacy"`` for ``"tron"``)
+      2 - query appears as a whole word/phrase inside the title
+      1 - query is a substring of the title
+      0 - no literal overlap (TMDb fuzzy match)
+    """
+    q = _normalize_for_match(query)
+    t = _normalize_for_match(title)
+    if not q or not t:
+        return 0
+    if t == q:
+        return 4
+    if t.startswith(q + " "):
+        return 3
+    if f" {q} " in f" {t} ":
+        return 2
+    if q in t:
+        return 1
+    return 0
+
+
 def _looks_like_read_access_token(key: str) -> bool:
     """Return ``True`` when *key* looks like a TMDb v4 Read Access Token.
 
@@ -105,19 +147,77 @@ class TmdbProvider(MetadataProvider):
         year: int | None = None,
         media_type: Literal["movie", "tv", "auto"] = "auto",
     ) -> list[MetadataSearchResult]:
-        results: list[MetadataSearchResult] = []
-
-        if media_type in ("movie", "auto"):
-            results.extend(await self._search_movies(query, year))
+        results: list[MetadataSearchResult]
 
-        if media_type in ("tv", "auto"):
-            results.extend(await self._search_tv(query, year))
+        if media_type == "auto" and year is None:
+            # No media-type or year constraint: use TMDb's /search/multi, the
+            # same endpoint the website's search box uses. It applies a
+            # server-side relevance score across movies and TV in one ranked
+            # list, which avoids the cross-endpoint merge problem (a single
+            # "movie" + "tv" merge has no shared score to order by).
+            results = await self._search_multi(query)
+        else:
+            # Explicit media type, or a year filter (which the dedicated
+            # endpoints support server-side but /search/multi does not).
+            results = []
+            if media_type in ("movie", "auto"):
+                results.extend(await self._search_movies(query, year))
+            if media_type in ("tv", "auto"):
+                results.extend(await self._search_tv(query, year))
 
-        # Sort by descending popularity (TMDb returns popularity-ordered, but
-        # we merged two lists).
-        results.sort(key=lambda r: r.popularity, reverse=True)
+        # Rank by literal title-match quality first, then popularity. TMDb's
+        # results are fuzzy (a "Tron" search returns unrelated high-popularity
+        # shows), so this keeps the title the user searched for on top while
+        # still using popularity to order within a tier. Applying it uniformly
+        # also gives a deterministic, offline-testable final ordering.
+        results.sort(
+            key=lambda r: (_title_match_tier(query, r.title), r.popularity),
+            reverse=True,
+        )
         return results
 
+    async def _search_multi(self, query: str) -> list[MetadataSearchResult]:
+        """Search movies and TV in one ranked list via /search/multi.
+
+        /search/multi also returns ``person`` and ``collection`` entities,
+        which have no single runtime or release year to match a ripped MKV
+        against. Those are filtered out; only ``movie`` and ``tv`` survive.
+        """
+        ck = cache.hash_key(f"multi|{query}")
+        data = await self._get_json("/search/multi", params={"query": query},
+                                    cache_ns="tmdb/search", cache_key=ck)
+        out: list[MetadataSearchResult] = []
+        for item in data.get("results", []):
+            mt = item.get("media_type")
+            if mt == "movie":
+                release = item.get("release_date", "") or ""
+                item_year = int(release[:4]) if len(release) >= 4 else None
+                out.append(
+                    MetadataSearchResult(
+                        source_id=f"movie:{item['id']}",
+                        title=item.get("title", ""),
+                        year=item_year,
+                        media_type="movie",
+                        overview=item.get("overview", ""),
+                        popularity=item.get("popularity", 0.0),
+                    )
+                )
+            elif mt == "tv":
+                air_date = item.get("first_air_date", "") or ""
+                item_year = int(air_date[:4]) if len(air_date) >= 4 else None
+                out.append(
+                    MetadataSearchResult(
+                        source_id=f"tv:{item['id']}",
+                        title=item.get("name", ""),
+                        year=item_year,
+                        media_type="tv",
+                        overview=item.get("overview", ""),
+                        popularity=item.get("popularity", 0.0),
+                    )
+                )
+            # person / collection entities are intentionally skipped.
+        return out
+
     async def _search_movies(
         self, query: str, year: int | None
     ) -> list[MetadataSearchResult]:

{riplex-0.9.4 → riplex-0.9.6/src/riplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.9.4
+Version: 0.9.6
 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.9.6/src/riplex.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.9.6",
+  "distance": 0,
+  "node": "g3311b030adbd0a061c09263e0868772b3915ab45",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-28"
+}

{riplex-0.9.4 → riplex-0.9.6}/tests/test_disc_analysis.py

@@ -412,6 +412,65 @@ class TestDetectDiscNumber:
         info = DiscInfo(disc_name="DISC", disc_type="Blu-ray disc", titles=titles)
         assert _detect_disc_number(info, [disc1]) is None
 
+    def test_4k_disc_matched_by_format_not_duration(self):
+        """A 4K movie disc whose feature has no listed runtime must still be
+        detected as the 4K disc via resolution — not mis-detected as the
+        Blu-ray disc that happens to list the same film's runtime.
+
+        Regression for the multi-format movie release case (issue: a 4K disc
+        was detected as disc 2 because disc 1's 4K feature had no runtime and
+        the inserted disc's film matched disc 2's listed 2D/3D runtimes).
+        """
+        class FakeEp:
+            def __init__(self, runtime):
+                self.title = "The Film"
+                self.runtime_seconds = runtime
+
+        class FakeDisc:
+            def __init__(self, number, fmt, ep_runtimes):
+                self.number = number
+                self.disc_format = fmt
+                self.episodes = [FakeEp(rt) for rt in ep_runtimes]
+                self.extras = []
+
+        # Disc 1 = 4K disc, but dvdcompare lists no runtime for its feature.
+        disc1 = FakeDisc(1, "Blu-ray 4K", [])
+        # Disc 2 = 3D Blu-ray, lists the 2D + 3D film runtimes (~ same length).
+        disc2 = FakeDisc(2, "3D Blu-ray", [2880, 2880])
+
+        # Inserted disc is the 4K disc: its single film title is 2160p and its
+        # runtime matches disc 2's listed film runtime.
+        titles = [_make_title(0, 2885, resolution="3840x2160")]
+        info = DiscInfo(disc_name="THE_LAST_REEF", disc_type="Blu-ray disc", titles=titles)
+        assert _detect_disc_number(info, [disc1, disc2]) == 1
+
+    def test_format_match_skipped_for_same_format_set(self):
+        """A multi-disc set where every disc is the same format must not be
+        resolved by format — it falls through to duration matching."""
+        class FakeEp:
+            def __init__(self, runtime):
+                self.title = "Ep"
+                self.runtime_seconds = runtime
+
+        class FakeDisc:
+            def __init__(self, number, runtimes):
+                self.number = number
+                self.disc_format = "Blu-ray 4K"
+                self.episodes = [FakeEp(rt) for rt in runtimes]
+                self.extras = []
+
+        # Both discs are 4K, so resolution can't distinguish them.
+        disc1 = FakeDisc(1, [3000, 3100, 3050])
+        disc2 = FakeDisc(2, [2800, 2900, 2950])
+        titles = [
+            _make_title(0, 2810, resolution="3840x2160"),
+            _make_title(1, 2910, resolution="3840x2160"),
+            _make_title(2, 2960, resolution="3840x2160"),
+        ]
+        info = DiscInfo(disc_name="MYSTERY_DISC", disc_type="Blu-ray disc", titles=titles)
+        assert _detect_disc_number(info, [disc1, disc2]) == 2
+
+
 
 class TestAnalyzeDisc:
     """Tests for the analyze_disc() shared entry point."""