riplex 0.9.4__tar.gz → 0.9.5__tar.gz

{riplex-0.9.4 → riplex-0.9.5}/.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.5}/.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.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.9.4
+Version: 0.9.5
 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.5}/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.5/src/riplex.egg-info}/PKG-INFO

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

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

riplex-0.9.5/tests/test_tmdb_provider.py

@@ -0,0 +1,211 @@
+import pytest
+
+from riplex.metadata.sources.tmdb import (
+    TmdbProvider,
+    _looks_like_read_access_token,
+    _title_match_tier,
+)
+
+# A JWT-shaped sample (header.payload.signature). Not a real credential.
+_SAMPLE_READ_ACCESS_TOKEN = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJyaXBsZXgifQ.c2lnbmF0dXJl"
+_SAMPLE_API_KEY = "0123456789abcdef0123456789abcdef"
+
+
+class TestLooksLikeReadAccessToken:
+    def test_jwt_token_is_detected(self):
+        assert _looks_like_read_access_token(_SAMPLE_READ_ACCESS_TOKEN) is True
+
+    def test_v3_hex_key_is_not_detected(self):
+        assert _looks_like_read_access_token(_SAMPLE_API_KEY) is False
+
+    def test_empty_string_is_not_detected(self):
+        assert _looks_like_read_access_token("") is False
+
+
+class TestTmdbProviderAuth:
+    @pytest.mark.asyncio
+    async def test_read_access_token_uses_authorization_header(self):
+        provider = TmdbProvider(api_key=_SAMPLE_READ_ACCESS_TOKEN)
+        try:
+            assert (
+                provider._client.headers["Authorization"]
+                == f"Bearer {_SAMPLE_READ_ACCESS_TOKEN}"
+            )
+            assert "api_key" not in provider._client.params
+        finally:
+            await provider.close()
+
+    @pytest.mark.asyncio
+    async def test_v3_key_uses_query_parameter(self):
+        provider = TmdbProvider(api_key=_SAMPLE_API_KEY)
+        try:
+            assert provider._client.params["api_key"] == _SAMPLE_API_KEY
+            assert "Authorization" not in provider._client.headers
+        finally:
+            await provider.close()
+
+    @pytest.mark.asyncio
+    async def test_whitespace_is_stripped_from_credential(self):
+        provider = TmdbProvider(api_key=f"  {_SAMPLE_API_KEY}  ")
+        try:
+            assert provider._client.params["api_key"] == _SAMPLE_API_KEY
+        finally:
+            await provider.close()
+
+    def test_missing_key_raises(self, monkeypatch):
+        monkeypatch.delenv("TMDB_API_KEY", raising=False)
+        with pytest.raises(ValueError, match="TMDb API key is required"):
+            TmdbProvider(api_key="")
+
+
+class TestTitleMatchTier:
+    def test_exact_match_ranks_highest(self):
+        assert _title_match_tier("Tron", "Tron") == 4
+
+    def test_match_is_case_insensitive(self):
+        assert _title_match_tier("tron", "TRON") == 4
+
+    def test_punctuation_is_ignored(self):
+        # "TRON: Legacy" should compare equal to "Tron Legacy".
+        assert _title_match_tier("Tron Legacy", "TRON: Legacy") == 4
+
+    def test_title_starting_with_query_outranks_substring(self):
+        assert _title_match_tier("Tron", "TRON: Legacy") == 3
+
+    def test_query_as_whole_word_inside_title(self):
+        assert _title_match_tier("Planet", "The Green Planet") == 2
+
+    def test_substring_without_word_boundary(self):
+        assert _title_match_tier("ron", "Tron") == 1
+
+    def test_no_overlap_ranks_lowest(self):
+        assert _title_match_tier("Tron", "House of the Dragon") == 0
+
+    def test_empty_query_ranks_lowest(self):
+        assert _title_match_tier("", "Tron") == 0
+
+    def test_relevance_beats_popularity_for_tron(self):
+        """The original Tron (low popularity) must outrank an unrelated but
+        wildly popular fuzzy match like House of the Dragon."""
+        original = ("Tron", 3.54)
+        fuzzy = ("House of the Dragon", 494.97)
+        ranked = sorted(
+            [original, fuzzy],
+            key=lambda item: (_title_match_tier("Tron", item[0]), item[1]),
+            reverse=True,
+        )
+        assert ranked[0] == original
+
+
+# Minimal /search/multi payload mirroring TMDb's real shape for "Tron":
+# a mix of movie, tv, person, and collection entities.
+_MULTI_TRON_PAYLOAD = {
+    "results": [
+        {
+            "id": 20526,
+            "media_type": "movie",
+            "title": "TRON: Legacy",
+            "release_date": "2010-12-14",
+            "overview": "Sam Flynn...",
+            "popularity": 14.15,
+        },
+        {
+            "id": 97,
+            "media_type": "movie",
+            "title": "Tron",
+            "release_date": "1982-07-09",
+            "overview": "A computer hacker...",
+            "popularity": 4.36,
+        },
+        {
+            "id": 44217,
+            "media_type": "tv",
+            "name": "TRON: Uprising",
+            "first_air_date": "2012-05-18",
+            "overview": "Beck becomes...",
+            "popularity": 6.34,
+        },
+        {
+            "id": 123,
+            "media_type": "person",
+            "name": "Tron Mai",
+            "popularity": 0.14,
+        },
+        {
+            "id": 456,
+            "media_type": "collection",
+            "name": "TRON Collection",
+            "overview": "The TRON franchise.",
+            "popularity": 2.0,
+        },
+    ]
+}
+
+
+class TestSearchMulti:
+    @pytest.mark.asyncio
+    async def test_auto_uses_multi_and_filters_person_and_collection(
+        self, monkeypatch
+    ):
+        provider = TmdbProvider(api_key=_SAMPLE_API_KEY)
+        calls: list[str] = []
+
+        async def fake_get_json(path, params=None, cache_ns=None, cache_key=None):
+            calls.append(path)
+            return _MULTI_TRON_PAYLOAD
+
+        monkeypatch.setattr(provider, "_get_json", fake_get_json)
+        try:
+            results = await provider.search("Tron")
+        finally:
+            await provider.close()
+
+        # Routed through /search/multi exactly once (not the per-type endpoints).
+        assert calls == ["/search/multi"]
+        # person and collection entities are dropped; only movie/tv survive.
+        assert {r.media_type for r in results} == {"movie", "tv"}
+        assert all(
+            r.title not in ("Tron Mai", "TRON Collection") for r in results
+        )
+        # Exact title match ("Tron") ranks first despite lower popularity.
+        assert results[0].title == "Tron"
+        assert results[0].year == 1982
+
+    @pytest.mark.asyncio
+    async def test_auto_with_year_uses_dedicated_endpoints(self, monkeypatch):
+        provider = TmdbProvider(api_key=_SAMPLE_API_KEY)
+        calls: list[str] = []
+
+        async def fake_get_json(path, params=None, cache_ns=None, cache_key=None):
+            calls.append(path)
+            return {"results": []}
+
+        monkeypatch.setattr(provider, "_get_json", fake_get_json)
+        try:
+            await provider.search("Tron", year=1982)
+        finally:
+            await provider.close()
+
+        # A year filter falls back to the dedicated endpoints (multi can't
+        # filter by year), so both movie and tv search are queried.
+        assert "/search/movie" in calls
+        assert "/search/tv" in calls
+        assert "/search/multi" not in calls
+
+    @pytest.mark.asyncio
+    async def test_explicit_media_type_uses_dedicated_endpoint(self, monkeypatch):
+        provider = TmdbProvider(api_key=_SAMPLE_API_KEY)
+        calls: list[str] = []
+
+        async def fake_get_json(path, params=None, cache_ns=None, cache_key=None):
+            calls.append(path)
+            return {"results": []}
+
+        monkeypatch.setattr(provider, "_get_json", fake_get_json)
+        try:
+            await provider.search("Game of Thrones", media_type="tv")
+        finally:
+            await provider.close()
+
+        assert calls == ["/search/tv"]
+

riplex-0.9.4/src/riplex.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.9.4",
-  "distance": 0,
-  "node": "g2e958718f2247e29a80b9323f72e3feab086e258",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-06-25"
-}

riplex-0.9.4/tests/test_tmdb_provider.py

@@ -1,57 +0,0 @@
-import pytest
-
-from riplex.metadata.sources.tmdb import (
-    TmdbProvider,
-    _looks_like_read_access_token,
-)
-
-# A JWT-shaped sample (header.payload.signature). Not a real credential.
-_SAMPLE_READ_ACCESS_TOKEN = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJyaXBsZXgifQ.c2lnbmF0dXJl"
-_SAMPLE_API_KEY = "0123456789abcdef0123456789abcdef"
-
-
-class TestLooksLikeReadAccessToken:
-    def test_jwt_token_is_detected(self):
-        assert _looks_like_read_access_token(_SAMPLE_READ_ACCESS_TOKEN) is True
-
-    def test_v3_hex_key_is_not_detected(self):
-        assert _looks_like_read_access_token(_SAMPLE_API_KEY) is False
-
-    def test_empty_string_is_not_detected(self):
-        assert _looks_like_read_access_token("") is False
-
-
-class TestTmdbProviderAuth:
-    @pytest.mark.asyncio
-    async def test_read_access_token_uses_authorization_header(self):
-        provider = TmdbProvider(api_key=_SAMPLE_READ_ACCESS_TOKEN)
-        try:
-            assert (
-                provider._client.headers["Authorization"]
-                == f"Bearer {_SAMPLE_READ_ACCESS_TOKEN}"
-            )
-            assert "api_key" not in provider._client.params
-        finally:
-            await provider.close()
-
-    @pytest.mark.asyncio
-    async def test_v3_key_uses_query_parameter(self):
-        provider = TmdbProvider(api_key=_SAMPLE_API_KEY)
-        try:
-            assert provider._client.params["api_key"] == _SAMPLE_API_KEY
-            assert "Authorization" not in provider._client.headers
-        finally:
-            await provider.close()
-
-    @pytest.mark.asyncio
-    async def test_whitespace_is_stripped_from_credential(self):
-        provider = TmdbProvider(api_key=f"  {_SAMPLE_API_KEY}  ")
-        try:
-            assert provider._client.params["api_key"] == _SAMPLE_API_KEY
-        finally:
-            await provider.close()
-
-    def test_missing_key_raises(self, monkeypatch):
-        monkeypatch.delenv("TMDB_API_KEY", raising=False)
-        with pytest.raises(ValueError, match="TMDb API key is required"):
-            TmdbProvider(api_key="")