riplex 0.6.1__tar.gz → 0.6.2__tar.gz

riplex-0.6.2/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+
+# Config file with API keys
+riplex.toml
+plex-planner.toml
+riplex_app.log

{riplex-0.6.1/src/riplex.egg-info → riplex-0.6.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.6.1
+Version: 0.6.2
 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
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.27
-Requires-Dist: dvdcompare-scraper>=0.1.7
+Requires-Dist: dvdcompare-scraper>=0.1.12
 Requires-Dist: platformdirs>=4.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"

{riplex-0.6.1 → riplex-0.6.2}/docs/changelog.md

@@ -4,6 +4,21 @@ All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## 2026-05-09
+
+### Changed
+
+- Installation guide: complete restructure for clarity. Install riplex first, then setup, then manual tool installation as a fallback. Each install option now covers all platforms (Windows, macOS, Linux, immutable Linux distros).
+- Installation guide: Windows executable instructions rewritten with step-by-step PATH setup, SmartScreen guidance, and separate GUI vs CLI paths.
+- Installation guide: macOS CLI now installs to `/usr/local/bin/riplex` with proper rename.
+- Installation guide: Option C (from source) split into numbered steps with separate Windows and macOS/Linux commands.
+- Installation guide: tkinter/folder picker note now covers both macOS and Linux.
+
+### Added
+
+- Installation guide: Linux (Bazzite, Fedora Silverblue, immutable distros) sections for pipx install and manual tool installation, including Flatpak wrapper script for MKVToolNix.
+- Installation guide: MakeMKV registration pulled into its own subsection.
+
 ## 2026-05-08
 
 ### Added

riplex-0.6.2/docs/getting-started/installation.md

@@ -0,0 +1,330 @@
+# Installation
+
+## Installing riplex
+
+There are three ways to install riplex:
+
+- **[Pre-built executables](#option-a-pre-built-executables)** - easiest, no Python needed
+- **[pipx](#option-b-install-with-pipx-recommended)** - recommended for Python users
+- **[From source](#option-c-install-from-source)** - for developers
+
+### Option A: Pre-built executables
+
+Download the latest release for your platform from the
+[GitHub Releases page](https://github.com/AnyCredit5518/riplex/releases).
+
+#### Windows
+
+**GUI only (easiest):**
+
+1. Download `riplex-ui-windows.exe`
+2. Move it wherever you keep apps (e.g. `C:\Program Files\riplex\`)
+3. Double-click to run. Windows SmartScreen may warn you because the app
+   isn't code-signed -- click **More info** then **Run anyway**.
+4. Optionally, right-click the `.exe` and select **Create shortcut** to add
+   it to your desktop or Start menu.
+
+**CLI (for terminal users):**
+
+1. Download `riplex-windows.exe`
+2. Rename it to `riplex.exe`
+3. Move it to a folder of your choice (e.g. `C:\Program Files\riplex\`)
+4. Add that folder to your system PATH:
+    - Open **Settings** > **System** > **About** > **Advanced system settings**
+    - Click **Environment Variables**
+    - Under **User variables**, select **Path** and click **Edit**
+    - Click **New** and paste the folder path (e.g. `C:\Program Files\riplex\`)
+    - Click **OK** on all dialogs
+5. Open a **new** terminal and run `riplex setup`
+
+> [!TIP]
+> You can install both. The GUI includes built-in setup, so you don't need
+> the CLI unless you prefer working in a terminal.
+
+#### macOS (Apple Silicon only)
+
+> **Intel Mac?** Pre-built binaries aren't available for Intel Macs. GitHub
+> [deprecated their Intel macOS build runners](https://github.blog/changelog/2024-09-16-github-actions-macos-13-larger-runner-image-brownout-dates/).
+> Use [Option B: Install with pipx](#option-b-install-with-pipx-recommended)
+> instead, which works on any Mac.
+
+**GUI:**
+
+1. Download `riplex-ui-macos.zip`
+2. Unzip it and move `riplex-ui.app` to `/Applications/`
+3. **Allow the app to open.** macOS blocks apps from unidentified developers.
+   The first time you open it, you'll see a warning -- do **not** click
+   "Move to Trash." Instead:
+
+    - **Right-click** (or Control-click) `riplex-ui.app`, choose **Open**,
+      then click **Open** in the dialog. macOS remembers this and won't ask
+      again.
+
+    - If that doesn't work, open Terminal and run:
+      ```
+      xattr -dr com.apple.quarantine /Applications/riplex-ui.app
+      ```
+
+**CLI:**
+
+1. Download `riplex-macos`
+2. Open Terminal and run:
+    ```
+    mv ~/Downloads/riplex-macos /usr/local/bin/riplex
+    chmod +x /usr/local/bin/riplex
+    xattr -dr com.apple.quarantine /usr/local/bin/riplex
+    ```
+3. Run `riplex setup`
+
+#### Linux
+
+Pre-built executables are not currently available for Linux. Use
+[Option B: Install with pipx](#option-b-install-with-pipx-recommended)
+instead.
+
+### Option B: Install with pipx (recommended)
+
+[pipx](https://pipx.pypa.io/) installs Python apps in isolated environments
+but makes their commands available globally. No venv activation needed --
+`riplex` and `riplex-ui` just work from any terminal.
+
+#### 1. Install Python and pipx
+
+**Windows:**
+
+Download Python from https://www.python.org/downloads/ and run the installer.
+**Check "Add Python to PATH"** at the bottom of the first screen. Then open
+a terminal and run:
+
+```
+pip install pipx
+pipx ensurepath
+```
+
+**macOS:**
+
+```
+brew install python pipx
+pipx ensurepath
+```
+
+**Linux (Debian, Ubuntu, Mint, Pop!_OS, etc.):**
+
+```
+sudo apt install python3 pipx
+pipx ensurepath
+```
+
+**Linux (Bazzite, Fedora Silverblue, and other immutable distros):**
+
+Python and pipx aren't available via `apt` on immutable distros. Layer them
+with `rpm-ostree`:
+
+```
+rpm-ostree install python3 python3-pip
+```
+
+Then reboot and run:
+
+```
+pip install --user pipx
+pipx ensurepath
+```
+
+Restart your terminal after `ensurepath` so the new PATH takes effect.
+
+#### 2. Install riplex
+
+```bash
+pipx install "riplex[gui]"
+```
+
+This installs both `riplex` (CLI) and `riplex-ui` (GUI) as globally available
+commands.
+
+> [!TIP]
+> To install the CLI only (no GUI), run `pipx install riplex` instead.
+
+#### Updating
+
+```bash
+pipx upgrade riplex
+```
+
+### Option C: Install from source
+
+For developers who want to contribute or run the latest unreleased code.
+
+#### 1. Clone the repository
+
+```bash
+git clone https://github.com/AnyCredit5518/riplex.git
+cd riplex
+```
+
+#### 2. Create and activate a virtual environment
+
+**Windows:**
+
+```
+py -m venv .venv
+.venv\Scripts\activate
+```
+
+**macOS / Linux:**
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+```
+
+#### 3. Install in development mode
+
+```bash
+pip install -e ".[dev,gui]"
+```
+
+> [!NOTE]
+> With a venv, `riplex` and `riplex-ui` only work while the venv is
+> activated. For a global install that works from any terminal, use
+> [pipx](#option-b-install-with-pipx-recommended) instead.
+
+> [!TIP]
+> The repo's `.vscode/settings.json` points VS Code at `.venv`
+> automatically, so the integrated terminal activates it on open.
+
+#### macOS SSL fix (Homebrew Python only)
+
+If you installed Python via Homebrew and `riplex-ui` crashes on first launch
+with an SSL certificate error, run this one-time fix:
+
+```bash
+CERT=$(python3.12 -c "import certifi; print(certifi.where())")
+echo "export SSL_CERT_FILE=\"$CERT\"" >> .venv/bin/activate
+echo "export REQUESTS_CA_BUNDLE=\"$CERT\"" >> .venv/bin/activate
+source .venv/bin/activate
+```
+
+#### GUI folder picker (tkinter)
+
+The browse buttons in the GUI use tkinter, which some platforms don't include
+by default. Without it, the browse buttons show a hint to type the path
+manually instead.
+
+- **macOS (Homebrew):** `brew install python-tk@3.12`
+- **Linux (Debian/Ubuntu):** `sudo apt install python3-tk`
+
+## Setup
+
+After installing, run the setup wizard. You can do this from the CLI:
+
+```bash
+riplex setup
+```
+
+Or just launch the GUI -- it checks for missing tools on startup and walks you
+through setup automatically.
+
+The setup wizard will:
+
+1. Ask for your TMDb API key (free at https://www.themoviedb.org/settings/api)
+
+    > [!TIP]
+    > TMDb asks for an app name and URL when you request a key. You can just
+    > enter "riplex" as the app name and `https://github.com/AnyCredit5518/riplex`
+    > as the URL. The rest of the form can be filled with basic info -- it
+    > doesn't need to be a real business. The key is approved instantly.
+
+2. Ask where your Plex library and MakeMKV rip folders are
+3. Check for required tools (MakeMKV, ffprobe, mkvmerge, mkvpropedit)
+4. Offer to install any missing tools automatically (via winget on Windows,
+   Homebrew on macOS, or apt on Debian/Ubuntu-based Linux)
+
+If you skip setup, it runs automatically the first time you use any command.
+
+### Verify
+
+```bash
+riplex --help
+riplex-ui
+```
+
+Both commands should work from any terminal.
+
+## Manual tool installation
+
+Most users don't need this section -- the setup wizard installs tools
+automatically on Windows, macOS (with Homebrew), and Debian/Ubuntu-based
+Linux. If the wizard couldn't install a tool for your platform, or you prefer
+to install manually, follow the instructions below.
+
+riplex requires these three tools:
+
+| Tool | Purpose |
+|---|---|
+| [MakeMKV](https://www.makemkv.com/) | Disc reading and ripping (`makemkvcon`) |
+| [FFmpeg](https://ffmpeg.org/) | MKV metadata probing (`ffprobe`) |
+| [MKVToolNix](https://mkvtoolnix.download/) | MKV splitting and tagging (`mkvmerge`, `mkvpropedit`) |
+
+### Windows
+
+```
+winget install GuinpinSoft.MakeMKV
+winget install Gyan.FFmpeg
+winget install MoritzBunkus.MKVToolNix
+```
+
+Or download installers from the links above. These installers add the tools to
+your PATH automatically.
+
+### macOS
+
+```
+brew install ffmpeg mkvtoolnix
+```
+
+MakeMKV must be downloaded from https://www.makemkv.com/ since it isn't in
+Homebrew. The app bundle includes `makemkvcon` automatically.
+
+### Linux (Debian, Ubuntu, Pop!_OS, Mint, etc.)
+
+```
+sudo apt install ffmpeg mkvtoolnix
+```
+
+MakeMKV must be downloaded from https://www.makemkv.com/ or built from
+source. See the [MakeMKV forum](https://forum.makemkv.com/forum/viewtopic.php?t=224)
+for instructions.
+
+### Linux (Bazzite, Fedora Silverblue, and other immutable distros)
+
+On immutable distros, `apt` isn't available. Use `rpm-ostree` to install
+packages:
+
+```
+rpm-ostree install ffmpeg mkvtoolnix
+```
+
+Then reboot for the changes to take effect.
+
+MakeMKV must be downloaded from https://www.makemkv.com/.
+
+> [!WARNING]
+> If you installed MKVToolNix as a Flatpak, `mkvmerge` won't be on your
+> system PATH even though the GUI works fine. Either layer it with
+> `rpm-ostree install mkvtoolnix` (recommended) or create a wrapper script:
+>
+> ```
+> sudo tee /usr/local/bin/mkvmerge << 'EOF'
+> #!/bin/sh
+> exec flatpak run --command=mkvmerge org.bunkus.mkvtoolnix-gui "$@"
+> EOF
+> sudo chmod +x /usr/local/bin/mkvmerge
+> ```
+
+### MakeMKV registration
+
+MakeMKV requires a registration key. A free beta key is available at
+https://forum.makemkv.com/forum/viewtopic.php?f=5&t=1053 and must be entered
+in MakeMKV (Help > Register) before `makemkvcon` will work. The beta key is
+updated periodically.

{riplex-0.6.1 → riplex-0.6.2}/issues/planned-features.md

@@ -21,38 +21,6 @@ episode collapsing.
   override for users with separate libraries.
 
 
-## Orchestrate Flow (GUI)
-
-The GUI has rip and organize flows. The orchestrate flow (multi-disc pipeline
-with disc-swap prompts) is not yet implemented.
-
-### Key pieces needed
-
-- Disc swap prompt screen
-- Session state tracking across disc swaps (accumulated rip results, metadata)
-- Disc number auto-detection after each swap
-- Error recovery (retry/skip failed disc)
-- Cancel mid-flow and organize what's been ripped so far
-
-
-## Bug Report Submission
-
-### Problem
-
-Snapshot files for debugging are mixed in with media files and have
-inconsistent formats. Users must hunt for debug artifacts across multiple
-locations when filing bug reports.
-
-### Plan
-
-1. Move all debug artifacts into a `_riplex/` subfolder (Plex-ignored).
-2. Consistent v2 snapshot envelope format with type discriminator.
-3. GUI writes same snapshots as CLI.
-4. "Report a Bug" button in GUI: opens pre-filled GitHub issue, copies
-   debug folder path to clipboard.
-5. `.github/ISSUE_TEMPLATE/bug_report.yml` for structured reports.
-
-
 ## Interactive Lookup Command
 
 `riplex lookup` currently auto-picks the first TMDb match and default
@@ -77,17 +45,4 @@ tracks when ripping, not just the default/English track.
   if the user explicitly configures preferred languages
 
 
-## Drop Pre-built Intel macOS Binary
-
-The `macos-13` (Intel) CI runner is slow to queue and GitHub is phasing out
-Intel Mac hardware. Intel Macs are a shrinking minority of users.
-
-### Plan
 
-- Remove the `macos-13` / `x86_64` matrix entry from `release.yml`
-- Remove `riplex-macos-x86_64` and `riplex-ui-macos-x86_64.zip` from the
-  release step
-- Update `updater.py` to stop looking for arch-specific assets (only arm64)
-- Update installation docs: macOS section offers only the ARM build; Intel
-  Mac users are directed to install from source (venv + `pip install -e`)
-- Update README download table accordingly

{riplex-0.6.1 → riplex-0.6.2}/pyproject.toml

@@ -11,7 +11,7 @@ requires-python = ">=3.11"
 license = {text = "MIT"}
 dependencies = [
     "httpx>=0.27",
-    "dvdcompare-scraper>=0.1.7",
+    "dvdcompare-scraper>=0.1.12",
     "platformdirs>=4.0",
 ]
 

{riplex-0.6.1 → riplex-0.6.2}/src/riplex/disc/provider.py

@@ -21,6 +21,7 @@ from riplex.models import PlannedDisc, PlannedEpisode, PlannedExtra
 log = logging.getLogger(__name__)
 
 _DVDCOMPARE_TTL_DAYS = 30
+_DVDCOMPARE_NEG_TTL_DAYS = 7
 _CACHE_NS = "dvdcompare"
 
 
@@ -39,9 +40,11 @@ class DiscProvider:
         self,
         cache_ns: str = _CACHE_NS,
         ttl_days: int = _DVDCOMPARE_TTL_DAYS,
+        neg_ttl_days: int = _DVDCOMPARE_NEG_TTL_DAYS,
     ) -> None:
         self.cache_ns = cache_ns
         self.ttl_days = ttl_days
+        self.neg_ttl_days = neg_ttl_days
 
     # -- lookup -----------------------------------------------------------
 
@@ -89,14 +92,31 @@ class DiscProvider:
         disc_format: str | None = None,
         year: int | None = None,
     ) -> FilmComparison:
-        """Fetch a FilmComparison, returning cached data when available."""
+        """Fetch a FilmComparison, returning cached data when available.
+
+        Negative lookups (no results on dvdcompare) are also cached with a
+        shorter TTL to avoid hammering the search endpoint for titles that
+        don't exist.
+        """
         cache_key = cache.hash_key(f"film|{title}|{disc_format}|{year}")
+
+        # Check for negative cache first (shorter TTL)
+        neg_cached = cache.cache_get(self.cache_ns, cache_key, ttl_days=self.neg_ttl_days)
+        if neg_cached is not None and neg_cached.get("_negative"):
+            log.debug("dvdcompare negative cache hit for '%s'", title)
+            raise LookupError(f"No dvdcompare results for '{title}' (cached)")
+
         cached = cache.cache_get(self.cache_ns, cache_key, ttl_days=self.ttl_days)
-        if cached is not None:
+        if cached is not None and not cached.get("_negative"):
             log.debug("dvdcompare film cache hit for '%s'", title)
             return _dict_to_film(cached)
 
-        film = await find_film(title, disc_format, year=year)
+        try:
+            film = await find_film(title, disc_format, year=year)
+        except LookupError:
+            log.debug("dvdcompare no results for '%s', caching negative result", title)
+            cache.cache_set(self.cache_ns, cache_key, {"_negative": True})
+            raise
         log.debug("dvdcompare find_film('%s', format=%s, year=%s): %d release(s)",
                   title, disc_format, year, len(film.releases) if film.releases else 0)
         cache.cache_set(self.cache_ns, cache_key, dataclasses.asdict(film))

{riplex-0.6.1 → riplex-0.6.2}/src/riplex/matcher.py

@@ -166,6 +166,12 @@ _MAX_MATCH_DELTA = 300
 
 _PLAY_ALL_RE = re.compile(r"\bplay\s*all\b", re.IGNORECASE)
 
+# Edition patterns in dvdcompare feature titles
+_EDITION_RE = re.compile(
+    r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
+    re.IGNORECASE,
+)
+
 
 def collect_disc_targets(
     discs: list[PlannedDisc],
@@ -178,6 +184,7 @@ def collect_disc_targets(
     whichever disc has ``is_film=True``).
     """
     targets: list[tuple[str, int, int | None]] = []
+    suppress_movie_target = False
 
     # Identify the film disc number (if any) so the movie target is
     # constrained to that disc's folder.
@@ -201,22 +208,42 @@ def collect_disc_targets(
 
         # Collect non-play-all extras as targets; play-all entries are
         # redundant when individual parts are also listed on the disc.
-        # Also skip "The Film ..." entries on film discs: they represent
-        # the main feature which is already covered by the movie target.
+        # Also skip "The Film ..." entries on film discs UNLESS there are
+        # multiple editions (e.g. Theatrical Cut + Extended Cut).
         play_all_extras: list[PlannedExtra] = []
         regular_extras: list[PlannedExtra] = []
+        film_entries: list[PlannedExtra] = []
         for ex in disc.extras:
-            if ex.runtime_seconds <= 0:
-                continue
             if disc.is_film and ex.title.lower().startswith("the film"):
-                log.debug("Disc %d: skipping film entry '%s' (covered by movie target)",
-                          disc.number, ex.title)
+                film_entries.append(ex)
+                continue
+            if ex.runtime_seconds <= 0:
                 continue
             if _PLAY_ALL_RE.search(ex.title):
                 play_all_extras.append(ex)
             else:
                 regular_extras.append(ex)
 
+        # Handle "The Film ..." entries on film discs
+        if len(film_entries) > 1:
+            # Multiple editions: create edition-aware targets and suppress
+            # the single TMDb movie target added above.  Runtimes may be
+            # zero when dvdcompare only lists the title/resolution; those
+            # are filled in during matching by pairing editions with files
+            # by duration order (shortest = theatrical, longest = extended).
+            suppress_movie_target = True
+            for ex in film_entries:
+                m = _EDITION_RE.search(ex.title)
+                edition = m.group(1) if m else ex.title
+                label = f"{prefix}: {edition} (movie)"
+                runtime = ex.runtime_seconds or 0
+                log.debug("Disc %d: multi-edition film entry '%s' -> target '%s' (%ds)",
+                          disc.number, ex.title, label, runtime)
+                targets.append((label, runtime, disc.number))
+        elif film_entries:
+            log.debug("Disc %d: skipping single film entry '%s' (covered by movie target)",
+                      disc.number, film_entries[0].title)
+
         # Only include play-all entries if there are no other targets on
         # this disc (episodes or regular extras) to match against.
         has_parts = bool(disc.episodes) or bool(regular_extras)
@@ -233,6 +260,12 @@ def collect_disc_targets(
                 label += f" ({ex.feature_type})"
             targets.append((label, ex.runtime_seconds, disc.number))
 
+    # If multi-edition entries replaced the single movie target, remove it
+    if suppress_movie_target and targets and "(movie)" in targets[0][0]:
+        removed = targets.pop(0)
+        log.debug("Suppressed single movie target '%s' in favor of edition targets",
+                  removed[0])
+
     return targets
 
 
@@ -427,16 +460,82 @@ def match_discs(
         claimed_files.add(fi)
         claimed_targets.add(ti)
 
+    # --- Pass 2: zero-runtime edition targets ---
+    # When dvdcompare lists multiple editions without runtimes (e.g.
+    # "Theatrical Cut" and "Extended Cut" both with runtime=0), pair
+    # unclaimed edition targets with unclaimed files by duration order:
+    # shortest file = theatrical, longest = extended/director's.
+    _THEATRICAL_WORDS = {"theatrical"}
+    _EXTENDED_WORDS = {"extended", "director", "unrated", "ultimate"}
+
+    zero_edition_targets = [
+        ti for ti, (label, runtime_s, _) in enumerate(targets)
+        if ti not in claimed_targets and runtime_s == 0 and "(movie)" in label
+    ]
+    if zero_edition_targets:
+        # Find unclaimed files on the same disc(s)
+        edition_disc = targets[zero_edition_targets[0]][2]
+        unclaimed_files = [
+            fi for fi in range(len(all_scanned))
+            if fi not in claimed_files
+            and all_scanned[fi].duration_seconds > 0
+            and (edition_disc is None or file_disc[fi] is None or file_disc[fi] == edition_disc)
+        ]
+        # Sort targets: theatrical first, then extended
+        def _edition_sort_key(ti: int) -> int:
+            label_lower = targets[ti][0].lower()
+            if any(w in label_lower for w in _THEATRICAL_WORDS):
+                return 0
+            if any(w in label_lower for w in _EXTENDED_WORDS):
+                return 1
+            return 2
+        zero_edition_targets.sort(key=_edition_sort_key)
+        # Sort files by duration (shortest first = theatrical)
+        unclaimed_files.sort(key=lambda fi: all_scanned[fi].duration_seconds)
+
+        for ti, fi in zip(zero_edition_targets, unclaimed_files):
+            sf = all_scanned[fi]
+            label = targets[ti][0]
+            log.debug("Edition match (no runtime): %s (%ds) -> '%s'",
+                      sf.name, sf.duration_seconds, label)
+            matched.append(
+                MatchCandidate(
+                    file_name=sf.name,
+                    file_duration_seconds=sf.duration_seconds,
+                    matched_label=label,
+                    matched_runtime_seconds=sf.duration_seconds,
+                    delta_seconds=0,
+                    confidence="medium",
+                    classification=sf.classification,
+                )
+            )
+            claimed_files.add(fi)
+            claimed_targets.add(ti)
+
     unmatched = [
         all_scanned[i]
         for i in range(len(all_scanned))
         if i not in claimed_files
     ]
-    missing = [
-        targets[i][0]
-        for i in range(len(targets))
-        if i not in claimed_targets
-    ]
+
+    # Only report missing targets from discs the user actually has
+    # folders for (or targets with no disc constraint).  If no folder
+    # mapped to any disc (e.g. single folder with no disc number),
+    # include all targets as missing (fallback to previous behavior).
+    present_discs = set(folder_map.values()) - {None}
+    if present_discs:
+        missing = [
+            targets[i][0]
+            for i in range(len(targets))
+            if i not in claimed_targets
+            and (targets[i][2] is None or targets[i][2] in present_discs)
+        ]
+    else:
+        missing = [
+            targets[i][0]
+            for i in range(len(targets))
+            if i not in claimed_targets
+        ]
 
     for sf in unmatched:
         log.debug("Unmatched file: %s (%ds)", sf.name, sf.duration_seconds)

{riplex-0.6.1 → riplex-0.6.2}/src/riplex/organizer.py

@@ -461,7 +461,15 @@ def _compute_destination(
     # Movie main file
     if "(movie)" in label:
         edition = None
-        if candidate.classification:
+        # Check for edition in label (from multi-edition disc targets)
+        # e.g. "Disc 1: Theatrical Cut (movie)"
+        if label.startswith("Disc ") and ": " in label:
+            edition_part = label.split(": ", 1)[1].replace(" (movie)", "")
+            m = _EDITION_RE.search(edition_part)
+            if m:
+                edition = m.group(1)
+        # Fallback: check rip-time classification
+        if not edition and candidate.classification:
             m = _EDITION_RE.search(candidate.classification)
             if m:
                 edition = m.group(1)