kryten-webqueue 0.34.9__tar.gz → 0.34.11__tar.gz

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+## [0.34.11] - 2026-08-13
+
+### Fixed
+
+- **Cover art now found for many more films.** Three improvements to the search
+  strategy in `CoverArtResolver`:
+
+  - **Retry thumbnail-source movies on every sync.** Previously any item with a
+    saved `cover_art_path` (including the thumbnail fallback) was never
+    re-checked against TMDB/OMDB. Now items with `cover_art_source='thumbnail'`
+    and `duration_sec > 1800` (movie-length) are retried on each catalog sync,
+    so a title that failed the first time around gets another chance.
+
+  - **Leading-year normalization.** Titles stored as `(1989) Godzilla vs.
+    Biollante` are now converted to `Godzilla vs. Biollante (1989)` before
+    the first TMDB/OMDB search attempt so the API sees a properly-formatted
+    query. (`_normalize_leading_year` helper; applied in `_search_tmdb` and
+    `_search_omdb`.)
+
+  - **Smarter `_clean_title`.** Year extraction now prefers a
+    parenthesised year over a bare leading year (fixes `1917 (2019)` extracting
+    year 2019, not 1917). Added noise-stripping for `(Dubbed)`, `(English)`,
+    `(Uncut)` and similar language/edition tags; trailing `Svengoolie`
+    attribution; and bare trailing quality markers like `HD`.
+
+## [0.34.10] - 2026-08-13
+
+### Fixed
+
+- **Startup crash.** `app.py` referenced the now-removed `playlist_pass` key in
+  the return value of `purge_promo_hide_state()`.
+
 ## [0.34.9] - 2026-08-13
 
 ### Changed

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kryten-webqueue
-Version: 0.34.9
+Version: 0.34.11
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT

kryten_webqueue-0.34.11/_tmp_check_covers.py

@@ -0,0 +1,38 @@
+import sqlite3
+
+DB = "/var/lib/kryten-webqueue/webqueue.db"
+conn = sqlite3.connect(f"file:{DB}?mode=ro", uri=True)
+conn.row_factory = sqlite3.Row
+
+# Check specific item
+cur = conn.execute(
+    "SELECT friendly_token, title, cover_art_path, cover_art_source FROM catalog WHERE friendly_token='0A9oGeit2'"
+)
+print("=== Deathsport item ===")
+for r in cur:
+    print(dict(r))
+
+# Overall cover art stats
+print("\n=== Cover art stats ===")
+cur2 = conn.execute(
+    "SELECT cover_art_source, COUNT(*) as cnt FROM catalog GROUP BY cover_art_source ORDER BY cnt DESC"
+)
+for r in cur2:
+    print(dict(r))
+
+# How many items have no cover art at all?
+cur3 = conn.execute(
+    "SELECT COUNT(*) as cnt FROM catalog WHERE cover_art_path IS NULL OR cover_art_path = ''"
+)
+row = cur3.fetchone()
+print(f"\nItems with no cover art path: {row['cnt']}")
+
+# Sample of items with no cover art (movies - duration > 3600)
+print("\n=== Sample no-art items (movies) ===")
+cur4 = conn.execute(
+    "SELECT friendly_token, title, cover_art_source FROM catalog WHERE (cover_art_path IS NULL OR cover_art_path = '') AND duration_sec > 3600 LIMIT 20"
+)
+for r in cur4:
+    print(dict(r))
+
+conn.close()

kryten_webqueue-0.34.11/_tmp_check_covers2.py

@@ -0,0 +1,33 @@
+import sqlite3
+
+conn = sqlite3.connect("file:/var/lib/kryten-webqueue/webqueue.db?mode=ro", uri=True)
+conn.row_factory = sqlite3.Row
+
+print("=== Thumbnail-source movies (sample) ===")
+cur = conn.execute(
+    "SELECT friendly_token, title FROM catalog "
+    "WHERE cover_art_source='thumbnail' AND duration_sec > 3600 "
+    "ORDER BY title LIMIT 40"
+)
+for r in cur:
+    print(f"{r['friendly_token']:12}  {r['title']}")
+
+print("\n=== TMDB-matched movies (sample for comparison) ===")
+cur2 = conn.execute(
+    "SELECT friendly_token, title FROM catalog "
+    "WHERE cover_art_source='tmdb' AND duration_sec > 3600 "
+    "ORDER BY title LIMIT 10"
+)
+for r in cur2:
+    print(f"{r['friendly_token']:12}  {r['title']}")
+
+print("\n=== thumbnail-source items where title looks clean (year + normal title) ===")
+cur3 = conn.execute(
+    "SELECT COUNT(*) as cnt FROM catalog "
+    "WHERE cover_art_source='thumbnail' AND duration_sec > 3600 "
+    "AND title GLOB '* (19[0-9][0-9])' OR title GLOB '* (20[0-9][0-9])'"
+)
+row = cur3.fetchone()
+print(f"Items with '(YYYY)' in title: {row['cnt']}")
+
+conn.close()

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/kryten_webqueue/app.py

@@ -57,11 +57,10 @@ async def lifespan(app: FastAPI):
     # recently-played rules). Cheap and idempotent; also cleans rows written by
     # older builds that classified promos only by pool membership.
     purged = await db.purge_promo_hide_state()
-    if purged["completions"] or purged["playlist_pass"]:
+    if purged["completions"]:
         logger.info(
-            "Purged promo recently-played state: %d completion(s), %d pass row(s)",
+            "Purged promo recently-played state: %d completion(s)",
             purged["completions"],
-            purged["playlist_pass"],
         )
     # Any job run still marked 'running' is an orphan from a prior crash/restart
     # (the running flag is in-memory only). Reconcile before registering jobs.

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/kryten_webqueue/catalog/images.py

@@ -11,15 +11,41 @@ from PIL import Image
 logger = logging.getLogger(__name__)
 
 
+def _normalize_leading_year(title: str) -> str:
+    """Move a leading parenthesised year to standard trailing position.
+
+    ``(1989) Godzilla vs. Biollante`` → ``Godzilla vs. Biollante (1989)``
+    Has no effect when the year is already trailing or absent.
+    """
+    m = re.match(r"^\s*[\(\[]((?:19|20)\d{2})[\)\]]\s*(.+)", title)
+    if m:
+        return f"{m.group(2).strip()} ({m.group(1)})"
+    return title
+
+
 def _clean_title(title: str) -> tuple[str, str | None]:
     """Return (cleaned_title, year_or_None) stripping common noise."""
-    # Extract 4-digit year in parens or at end: "Title (2019)" or "Title 2019"
-    year = None
-    m = re.search(r"\b((?:19|20)\d{2})\b", title)
+    # Prefer a year in parentheses/brackets — it's almost always the movie year.
+    # A bare leading year like "1917 (2019)" has the year as its TITLE, not its
+    # release year, so the parenthesised form wins when both are present.
+    m = re.search(r"[\(\[]((?:19|20)\d{2})[\)\]]", title)
     if m:
-        year = m.group(1)
-    # Remove year, episode tags, resolution tags, etc.
-    cleaned = re.sub(r"\s*[\(\[]?(?:19|20)\d{2}[\)\]]?", "", title)
+        year: str | None = m.group(1)
+    else:
+        m = re.search(r"\b((?:19|20)\d{2})\b", title)
+        year = m.group(1) if m else None
+
+    # Remove ONLY the identified year (with its surrounding brackets if any).
+    if year:
+        cleaned = re.sub(r"\s*[\(\[]\s*" + year + r"\s*[\)\]]", "", title)
+        # Also remove a bare occurrence of the same year if it has word boundaries
+        # on both sides (handles "Title 1978" format) but NOT when the year IS
+        # the title ("1917").
+        cleaned = re.sub(r"(?<=\s)" + year + r"(?=\s|$)", "", cleaned).strip()
+    else:
+        cleaned = title
+
+    # Episode tags, resolution/encoding, dub/language noise.
     cleaned = re.sub(r"\s*[Ss]\d{1,2}[Ee]\d{1,2}.*", "", cleaned)
     cleaned = re.sub(
         r"\s*\b(?:720p|1080p|2160p|4K|HDR|BluRay|BDRip|WEB[-.]?DL|HDTV)\b.*",
@@ -27,6 +53,22 @@ def _clean_title(title: str) -> tuple[str, str | None]:
         cleaned,
         flags=re.IGNORECASE,
     )
+    cleaned = re.sub(
+        r"\s*[\(\[]\s*(?:Dubbed|English Dubbed|English Dub|Dub|Sub(?:bed)?|"
+        r"English|Uncut|Extended(?: Cut)?|Director'?s? Cut|Remastered|HD|SD)\s*[\)\]]",
+        "",
+        cleaned,
+        flags=re.IGNORECASE,
+    )
+    # Strip trailing Svengoolie attribution (e.g. "Tarantula Svengoolie").
+    cleaned = re.sub(r"\s+Svengoolie\b.*", "", cleaned, flags=re.IGNORECASE)
+    # Strip trailing bare quality/edition markers (e.g. "Title HD" or "Title Uncut").
+    cleaned = re.sub(
+        r"\s+\b(?:HD|SD|4K|Uncut|Remastered|Extended)\b\s*$",
+        "",
+        cleaned,
+        flags=re.IGNORECASE,
+    )
     cleaned = cleaned.strip(" .-")
     return cleaned or title, year
 
@@ -149,12 +191,15 @@ class CoverArtResolver:
 
     async def _search_tmdb(self, title: str) -> str | None:
         """Search TMDB for a poster: tries movie+TV in parallel, retries with cleaned title."""
-        result = await self._tmdb_search_both(title)
+        # Normalise leading-year format before the first attempt so TMDB sees
+        # 'Title (Year)' rather than '(Year) Title'.
+        normalized = _normalize_leading_year(title)
+        result = await self._tmdb_search_both(normalized)
         if result:
             return result
-        # Retry with cleaned title if it differs
-        cleaned, year = _clean_title(title)
-        if cleaned != title:
+        # Retry with fully-cleaned title + year filter.
+        cleaned, year = _clean_title(normalized)
+        if cleaned != normalized:
             result = await self._tmdb_search_both(cleaned, year=year)
         return result
 
@@ -205,8 +250,11 @@ class CoverArtResolver:
         return None, 0.0
 
     async def _search_omdb(self, title: str) -> str | None:
-        cleaned, year = _clean_title(title)
-        for t in dict.fromkeys([title, cleaned]):  # try original then cleaned, deduped
+        normalized = _normalize_leading_year(title)
+        cleaned, year = _clean_title(normalized)
+        for t in dict.fromkeys(
+            [normalized, cleaned]
+        ):  # try normalized then cleaned, deduped
             params: dict = {"apikey": self._omdb_key, "t": t}
             if year:
                 params["y"] = year

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/kryten_webqueue/catalog/sync.py

@@ -160,8 +160,17 @@ class CatalogSync:
         except Exception as e:
             logger.debug(f"Facet sync failed for {token}: {e}")
 
-        # Fetch TMDB/OMDB cover art if not already cached
-        if self._cover_art and not (existing and existing.get("cover_art_path")):
+        # Fetch TMDB/OMDB cover art.
+        # Skip only if we already have a real poster (tmdb/omdb source).
+        # Retry thumbnail-source items that are long enough to be movies — the
+        # thumbnail fallback fires when TMDB/OMDB return nothing, but a better
+        # title match on a subsequent sync may now succeed.
+        has_real_art = existing and existing.get("cover_art_source") in ("tmdb", "omdb")
+        is_movie_length = (row.get("duration_sec") or 0) > 1800
+        needs_cover = not has_real_art and (
+            not existing or is_movie_length or not existing.get("cover_art_path")
+        )
+        if self._cover_art and needs_cover:
             try:
                 await self._cover_art.resolve(token, row["title"], self._db)
             except Exception as e:

{kryten_webqueue-0.34.9 → kryten_webqueue-0.34.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryten-webqueue"
-version = "0.34.9"
+version = "0.34.11"
 description = "Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube"
 readme = "README.md"
 license = "MIT"