riplex 0.7.4__tar.gz → 0.9.0__tar.gz

{riplex-0.7.4/src/riplex.egg-info → riplex-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.7.4
+Version: 0.9.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.7.4 → riplex-0.9.0}/docs/changelog.md

@@ -4,6 +4,37 @@ All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## v0.9.0 — 2026-06-13
+
+Summary: Plex-aligned movie version and edition support for combo-disc releases, with better organize preview matching for 4K, Blu-ray, and 3D movie rips.
+
+### Added
+
+- **Plex movie versions and editions.** Movie organization now distinguishes Plex versions, such as `4k` and `1080p`, from Plex editions, such as `{edition-3D}`. Multiple 2D resolutions are organized together in the base movie folder, while 3D rips are organized as a separate Plex edition folder.
+- **3D movie edition output.** 3D movie rips now use Plex's edition naming convention in both folder and file names, for example `Movie Title (Year) {edition-3D}/Movie Title (Year) - 1080p {edition-3D}.mkv`.
+- **Combo-pack movie matching.** Multi-disc releases with separate 4K, Blu-ray, and 3D film discs now match each main feature independently so the 4K movie, standard 1080p movie, and 3D edition can all be organized from the same release.
+
+### Changed
+
+- **2D is treated as the base movie, not an edition.** dvdcompare labels such as `2D` are still useful for matching disc targets, but the organized Plex output keeps 2D files in the normal `Movie Title (Year)` folder instead of creating `{edition-2D}` folders.
+- **Resolution suffixes are inferred from scanned video dimensions.** Standard Blu-ray movie rips now receive a `- 1080p` suffix when ffprobe reports 1920x1080 video, matching the existing `- 4k` behavior for 2160p content.
+- **Duplicate bonus features no longer clutter the missing list.** If the same bonus feature appears on multiple discs and one copy is matched, equivalent duplicate targets from other present discs are suppressed from the organize preview's missing section.
+
+### Fixed
+
+- **4K main feature skipped in 4K + 3D combo releases.** Multi-edition film entries on a separate 3D/2D Blu-ray disc no longer suppress the generic movie target needed to match a separate 4K film disc.
+- **Matched extras still shown as missing.** Duplicate extras such as `Behind The Scenes` and `Humpback Whales` no longer appear under missing after one copy has already been matched and planned for organization.
+
+## v0.8.0 — 2026-06-12
+
+### Added
+
+- **GUI: editable settings after first-run setup.** The welcome screen now exposes an **Edit Settings** button after configuration is complete, so users can update the TMDb API key, media library root, MakeMKV rip output folder, and optional archive folder without re-running setup from the command line.
+
+### Changed
+
+- **GUI: less Plex-specific library wording.** User-facing destination copy now refers to a general media library while retaining **Plex-compatible naming** where the current folder/file convention is being described.
+
 ## v0.7.4 — 2026-06-10
 
 ### Fixed

{riplex-0.7.4 → riplex-0.9.0}/src/riplex/disc/analysis.py

@@ -16,6 +16,7 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|2D|IMAX|Open Matte)\b", re.IGNORECASE)
 
 # Feature types that indicate featurette/bonus content (not episodes)
 _FEATURETTE_PLAY_ALL_TYPES = frozenset({
@@ -72,6 +73,70 @@ def _detect_edition_name(
     return candidates[0]
 
 
+def _extract_movie_edition(text: str) -> str | None:
+    """Extract a movie edition label from dvdcompare film-entry text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return None
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
+
+
+def _apply_movie_variant_classifications(
+    classifications: dict[int, str],
+    titles: list,
+    current_disc_entries: list,
+    movie_runtime: int | None,
+) -> None:
+    """Label same-runtime movie variants such as 3D/2D using dvdcompare hints."""
+    if not movie_runtime:
+        return
+
+    film_entries = []
+    for disc in current_disc_entries:
+        if not getattr(disc, "is_film", False):
+            continue
+        for extra in getattr(disc, "extras", []):
+            title = getattr(extra, "title", "")
+            if not title.lower().startswith("the film"):
+                continue
+            edition = _extract_movie_edition(title)
+            if edition:
+                film_entries.append((edition, getattr(extra, "runtime_seconds", 0) or 0))
+
+    if len(film_entries) < 2:
+        return
+
+    candidate_titles = [
+        title for title in titles
+        if abs(title.duration_seconds - movie_runtime) < 60
+        and classifications.get(title.index, "").startswith("MAIN FILM")
+    ]
+    if len(candidate_titles) < 2:
+        return
+
+    edition_names = [edition for edition, _ in film_entries]
+    has_3d_2d = "3D" in edition_names and "2D" in edition_names
+    if has_3d_2d:
+        sorted_entries = sorted(film_entries, key=lambda entry: 0 if entry[0] == "3D" else 1)
+        sorted_titles = sorted(candidate_titles, key=lambda title: title.size_bytes, reverse=True)
+    else:
+        sorted_entries = sorted(
+            film_entries,
+            key=lambda entry: 0 if "theatrical" in entry[0].lower() else 1,
+        )
+        sorted_titles = sorted(candidate_titles, key=lambda title: title.duration_seconds)
+
+    for title, (edition, _) in zip(sorted_titles, sorted_entries):
+        res_label = "4K" if "3840" in (title.resolution or "") else "1080p"
+        classifications[title.index] = f"{edition} Edition ({res_label})"
+
+
 def format_seconds(seconds: int) -> str:
     """Format seconds as MM:SS or H:MM:SS."""
     m, s = divmod(seconds, 60)
@@ -593,6 +658,10 @@ def analyze_disc(
             t, titles, dvd_entries, is_movie, effective_movie_runtime,
             total_episode_runtime, episode_count,
         )
+    if is_movie:
+        _apply_movie_variant_classifications(
+            classifications, titles, current_disc_entries, effective_movie_runtime,
+        )
 
     return DiscAnalysis(
         disc_number=disc_number,

{riplex-0.7.4 → riplex-0.9.0}/src/riplex/matcher.py

@@ -188,6 +188,24 @@ def _is_unidentified(classification: str) -> bool:
         return False
     return classification.startswith(_UNIDENTIFIED_CLASSIFICATION_PREFIXES)
 
+
+_DISC_LABEL_PREFIX_RE = re.compile(r"^Disc\s+\d+:\s*", re.IGNORECASE)
+_TRAILING_TYPE_RE = re.compile(
+    r"\s+\((?:featurette|documentary|interview|interviews|deleted scenes?|trailer|trailers|short|shorts)\)$",
+    re.IGNORECASE,
+)
+
+
+def _duplicate_content_key(label: str) -> str | None:
+    """Return a cross-disc comparison key for duplicate non-movie targets."""
+    if _is_movie_target(label):
+        return None
+    key = _DISC_LABEL_PREFIX_RE.sub("", label).strip()
+    key = _TRAILING_TYPE_RE.sub("", key).strip()
+    if not key:
+        return None
+    return re.sub(r"\s+", " ", key).casefold()
+
 _PLAY_ALL_RE = re.compile(r"\bplay\s*all\b", re.IGNORECASE)
 
 # Edition patterns in dvdcompare feature titles
@@ -195,6 +213,21 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|2D|IMAX|Open Matte)\b", re.IGNORECASE)
+
+
+def _extract_movie_edition(text: str) -> str:
+    """Extract a Plex movie edition label from dvdcompare film-entry text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return ""
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
 
 
 def collect_disc_targets(
@@ -251,14 +284,15 @@ def collect_disc_targets(
         # 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
+            # the single TMDb movie target added above only when it would
+            # point at this same disc.  In combo packs, a separate 4K disc
+            # can be the base movie while a Blu-ray disc carries 3D/2D
+            # variants; those need both the generic movie target and the
+            # edition-aware targets.
+            if film_disc_num is None or disc.number == film_disc_num:
+                suppress_movie_target = True
             for ex in film_entries:
-                m = _EDITION_RE.search(ex.title)
-                edition = m.group(1) if m else ex.title
+                edition = _extract_movie_edition(ex.title) or 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)",
@@ -515,14 +549,6 @@ def match_discs(
         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()
@@ -531,28 +557,55 @@ def match_discs(
             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,
-                )
+
+        edition_discs = sorted(
+            {targets[ti][2] for ti in zero_edition_targets},
+            key=lambda d: -1 if d is None else d,
+        )
+        for edition_disc in edition_discs:
+            disc_targets = [ti for ti in zero_edition_targets if targets[ti][2] == edition_disc]
+            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)
+            ]
+
+            disc_targets.sort(key=_edition_sort_key)
+            target_labels = [targets[ti][0].lower() for ti in disc_targets]
+            has_3d_2d_targets = (
+                any("3d" in label for label in target_labels)
+                and any("2d" in label for label in target_labels)
             )
-            claimed_files.add(fi)
-            claimed_targets.add(ti)
+            if has_3d_2d_targets:
+                # 3D MVC titles carry an extra eye view and are typically larger
+                # than their same-runtime 2D companion on the same disc.
+                disc_targets.sort(
+                    key=lambda ti: 0 if "3d" in targets[ti][0].lower() else 1
+                )
+                unclaimed_files.sort(key=lambda fi: all_scanned[fi].size_bytes, reverse=True)
+            else:
+                # Sort files by duration (shortest first = theatrical)
+                unclaimed_files.sort(key=lambda fi: all_scanned[fi].duration_seconds)
+
+            for ti, fi in zip(disc_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]
@@ -560,6 +613,17 @@ def match_discs(
         if i not in claimed_files
     ]
 
+    matched_content_keys = {
+        key for key in (_duplicate_content_key(targets[i][0]) for i in claimed_targets)
+        if key is not None
+    }
+
+    def _is_missing_target(target_index: int) -> bool:
+        if target_index in claimed_targets:
+            return False
+        key = _duplicate_content_key(targets[target_index][0])
+        return key is None or key not in matched_content_keys
+
     # 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),
@@ -569,14 +633,14 @@ def match_discs(
         missing = [
             targets[i][0]
             for i in range(len(targets))
-            if i not in claimed_targets
+            if _is_missing_target(i)
             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
+            if _is_missing_target(i)
         ]
 
     for sf in unmatched:

{riplex-0.7.4 → riplex-0.9.0}/src/riplex/normalize.py

@@ -86,10 +86,18 @@ def movie_folder_name(title: str, year: int, edition: str | None = None) -> str:
     return name
 
 
-def movie_file_name(title: str, year: int, ext: str = ".mkv", edition: str | None = None) -> str:
+def movie_file_name(
+    title: str,
+    year: int,
+    ext: str = ".mkv",
+    edition: str | None = None,
+    version_suffix: str = "",
+) -> str:
     """Build the canonical Plex movie filename."""
     safe = sanitize_filename(title)
     name = f"{safe} ({year})"
+    if version_suffix:
+        name += f" - {sanitize_filename(version_suffix)}"
     if edition:
         name += f" {{edition-{edition}}}"
     return f"{name}{ext}"

{riplex-0.7.4 → riplex-0.9.0}/src/riplex/organizer.py

@@ -35,6 +35,43 @@ _EDITION_RE = re.compile(
     r"((?:Extended|Director'?s|Unrated|Ultimate|Special|Theatrical)\s+(?:Cut|Edition|Version))",
     re.IGNORECASE,
 )
+_FORMAT_EDITION_RE = re.compile(r"\b(3D|IMAX|Open Matte)\b", re.IGNORECASE)
+_VERSION_4K_RE = re.compile(r"\b(?:4K|2160p)\b", re.IGNORECASE)
+_VERSION_1080P_RE = re.compile(r"\b1080p\b", re.IGNORECASE)
+
+
+def _extract_movie_edition(text: str) -> str:
+    """Extract a Plex movie edition label from classifier/match text."""
+    m = _EDITION_RE.search(text)
+    if m:
+        return m.group(1)
+    m = _FORMAT_EDITION_RE.search(text)
+    if not m:
+        return ""
+    value = m.group(1)
+    if value.lower() == "open matte":
+        return "Open Matte"
+    return value.upper()
+
+
+def _extract_movie_version_suffix(text: str) -> str:
+    """Extract a Plex multi-version suffix from classifier/match text."""
+    if _VERSION_4K_RE.search(text):
+        return "4k"
+    if _VERSION_1080P_RE.search(text):
+        return "1080p"
+    return ""
+
+
+def _infer_movie_version_suffix(scanned_file: ScannedFile | None, edition: str | None) -> str:
+    """Infer a Plex multi-version suffix from scanned video dimensions."""
+    if not scanned_file:
+        return ""
+    if scanned_file.max_width >= 3840 or scanned_file.max_height >= 2160:
+        return "4k"
+    if scanned_file.max_width >= 1920 or scanned_file.max_height >= 1080:
+        return "1080p"
+    return ""
 
 # Map dvdcompare feature_type strings to Plex extras folder names
 _EXTRAS_FOLDER_MAP: dict[str, str] = {
@@ -380,7 +417,7 @@ def build_organize_plan(
                         )
                         continue
 
-        dest = _compute_destination(candidate, plan, base)
+        dest = _compute_destination(candidate, plan, base, scanned_files.get(candidate.file_name))
         if dest is None:
             # Could not resolve to a valid Plex path; treat as unmatched.
             log.debug("No valid destination for '%s' (label='%s'), treating as unmatched",
@@ -452,6 +489,7 @@ def _compute_destination(
     candidate: MatchCandidate,
     plan: PlannedMovie | PlannedShow,
     base: Path,
+    scanned_file: ScannedFile | None = None,
 ) -> Path | None:
     """Compute the Plex-canonical destination path for a matched file.
 
@@ -464,20 +502,29 @@ def _compute_destination(
     # Movie main file
     if "(movie)" in label:
         edition = None
+        version_suffix = ""
         # 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)
+            edition = _extract_movie_edition(edition_part) or None
+            version_suffix = _extract_movie_version_suffix(edition_part)
         # Fallback: check rip-time classification
         if not edition and candidate.classification:
-            m = _EDITION_RE.search(candidate.classification)
-            if m:
-                edition = m.group(1)
-        dest = base / movie_file_name(plan.canonical_title, plan.year, edition=edition)
-        log.debug("  -> movie main file (edition=%s): %s", edition, dest)
+            edition = _extract_movie_edition(candidate.classification) or None
+        if not version_suffix and candidate.classification:
+            version_suffix = _extract_movie_version_suffix(candidate.classification)
+        if not version_suffix:
+            version_suffix = _infer_movie_version_suffix(scanned_file, edition)
+        movie_base = base.parent / movie_folder_name(plan.canonical_title, plan.year, edition=edition) if edition else base
+        file_name = movie_file_name(
+            plan.canonical_title,
+            plan.year,
+            edition=edition,
+            version_suffix=version_suffix,
+        )
+        dest = movie_base / file_name
+        log.debug("  -> movie main file (edition=%s, version=%s): %s", edition, version_suffix, dest)
         return dest
 
     # Episode: label like "Disc 1: Coasts" or "s01e01 - Title"

{riplex-0.7.4 → riplex-0.9.0/src/riplex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.7.4
+Version: 0.9.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.7.4 → riplex-0.9.0}/src/riplex.egg-info/SOURCES.txt

@@ -123,6 +123,7 @@ tests/test_splitter.py
 tests/test_tagger.py
 tests/test_ui.py
 tests/test_updater.py
+tests/test_welcome_screen.py
 tests/fixtures/chernobyl_disc1.json
 tests/fixtures/makemkvcon_frozen_planet_ii_d2.txt
 tests/fixtures/makemkvcon_list.txt

{riplex-0.7.4 → riplex-0.9.0}/src/riplex_app/screens/done.py

@@ -87,7 +87,7 @@ class DoneScreen:
 
         no_metadata_hint = ft.Text(
             "Ripped without metadata — use 'Organize Rips' from the home screen "
-            "when TMDb is available to move these files into your Plex library.",
+            "when TMDb is available to move these files into your media library.",
             size=12,
             color=ft.Colors.ORANGE,
         ) if tmdb_match is None and len(successful) > 0 else ft.Container()

{riplex-0.7.4 → riplex-0.9.0}/src/riplex_app/screens/metadata.py

@@ -149,7 +149,7 @@ class MetadataScreen:
             [
                 ft.Text("Metadata Lookup", size=24, weight=ft.FontWeight.BOLD),
                 ft.Text(
-                    "TMDb is needed for canonical titles, years, and Plex folder "
+                    "TMDb is needed for canonical titles, years, and media-library folder "
                     "structure. Without it, you can still rip the disc and organize later.",
                     size=13,
                     color=ft.Colors.GREY_500,

{riplex-0.7.4 → riplex-0.9.0}/src/riplex_app/screens/orchestrate_done.py

@@ -17,7 +17,7 @@ class OrchestrateDoneScreen:
     """Shown after all discs in the orchestrate queue have been ripped.
 
     Displays a summary of all disc rips and offers to organize the
-    ripped files into Plex-compatible folder structure.
+    ripped files into a Plex-compatible folder structure.
     """
 
     def __init__(self, app):
@@ -108,7 +108,7 @@ class OrchestrateDoneScreen:
             on_click=self._open_folder,
         )
         organize_btn = ft.ElevatedButton(
-            "Organize into Plex",
+            "Organize into Library",
             icon=ft.Icons.DRIVE_FILE_MOVE,
             on_click=self._organize,
             style=ft.ButtonStyle(
@@ -136,8 +136,8 @@ class OrchestrateDoneScreen:
                 ft.Column(disc_rows, spacing=6),
                 ft.Container(height=10),
                 ft.Text(
-                    "All selected discs have been ripped. Click 'Organize into Plex' "
-                    "to match files to metadata and move them into your Plex library.",
+                    "All selected discs have been ripped. Click 'Organize into Library' "
+                    "to match files to metadata and move them into your media library.",
                     size=13,
                     color=ft.Colors.GREY_500,
                 ),
@@ -202,7 +202,7 @@ class OrchestrateDoneScreen:
                 self._organize_status.value = f"Error: {exc}"
                 self._organize_status.color = ft.Colors.RED
                 e.control.disabled = False
-                e.control.text = "Organize into Plex"
+                e.control.text = "Organize into Library"
                 self.app.page.update()
 
         threading.Thread(target=_do_organize, daemon=True).start()