kryten-webqueue 0.36.5__tar.gz → 0.36.7__tar.gz

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [0.36.7] - 2026-08-14
+
+### Fixed
+
+- **`force` now re-derives classification from the raw title.** The enrichment
+  pipeline cached `content_type`/`lookup_title` from the first classify run and
+  reused them on every subsequent run — so classify-logic improvements (e.g. the
+  new dub/sub and YouTube-pipe title cleaning) never reached already-classified
+  items even under `force`. A forced run now bypasses the cache and recomputes
+  the classification, so title/lookup fixes take effect on re-enrichment.
+
+## [0.36.6] - 2026-08-14
+
+### Fixed
+
+- **`(Dubbed)` / `(Subbed)` markers no longer break art lookup.** `(dubbed)` is
+  stripped from both the display title and the search query (dubbed is the
+  default). `(subbed)`/`(subs)`/`(subtitles)` stay in the display title but are
+  omitted from the metadata/art search.
+- **YouTube “full movie” pipe titles are cleaned properly.** Detection now matches
+  non-adjacent variants like “Full **Horror** Movie”, the title is taken from the
+  first segment before the pipe, and the year is extracted from the whole string
+  (it often trails after the last pipe, e.g. “… | Larry Bucha (1961)”). Both the
+  search query and the display title use this cleanup consistently (previously the
+  display title was never tidied for pipe uploads).
+
 ## [0.36.5] - 2026-08-14
 
 ### Changed

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/PKG-INFO

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

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/kryten_webqueue/catalog/enrichment/classify.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass, field
 
-from .normalise import normalize_and_clean, strip_extension
+from .normalise import normalize_movie_title
 
 # ---------------------------------------------------------------------------
 # Hosted show registry
@@ -250,13 +250,6 @@ class ItemClassification:
     has_real_art: bool = False
 
 
-# YouTube "Title | English Full Movie | Genre1 Genre2" pattern
-# Also handles variants like "Title | Full Movie HD | Description"
-_YT_FULL_MOVIE_RE = re.compile(
-    r"^(?P<title>.+?)\s*\|.*(Full\s+(?:Movie|Film|Length|Feature)).*$", re.I
-)
-
-
 def classify_item(
     friendly_token: str,
     raw_title: str,
@@ -326,26 +319,9 @@ def classify_item(
 
     # 4. Movie (>= 30 min)
     if duration_sec >= 1800:
-        # YouTube title cleanup: extract title before first pipe if "full movie" appears
-        yt = _YT_FULL_MOVIE_RE.match(raw_title.strip())
-        if yt:
-            clean_title = yt.group("title").strip()
-            # Extract year from the clean title part
-            clean_title, year = normalize_and_clean(clean_title)
-            return ItemClassification(
-                friendly_token=friendly_token,
-                raw_title=raw_title,
-                content_type="movie",
-                hosted=None,
-                lookup_title=clean_title,
-                lookup_year=year,
-                genre_hints=[],
-                duration_sec=duration_sec,
-                description_score=description_score,
-                has_real_art=has_real_art,
-            )
-
-        clean_title, year = normalize_and_clean(raw_title)
+        # Handles YouTube pipe titles and dub/sub markers; year is pulled from
+        # the whole string so a trailing "(1961)" after pipes is still captured.
+        clean_title, year = normalize_movie_title(raw_title, for_search=True)
         return ItemClassification(
             friendly_token=friendly_token,
             raw_title=raw_title,

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/kryten_webqueue/catalog/enrichment/normalise.py

@@ -103,3 +103,57 @@ def normalize_and_clean(title: str) -> tuple[str, str | None]:
     t = strip_extension(t.strip(" .-"))
     t = re.sub(r"\s+", " ", t).strip()
     return t or title, year
+
+
+# ---------------------------------------------------------------------------
+# Dub / sub markers and YouTube "full movie" pipe titles
+# ---------------------------------------------------------------------------
+
+# "dubbed" is the default expectation → stripped from title and search.
+_DUB_TERMS = ["dubbed"]
+# sub markers stay in the display title but are omitted from art/metadata search.
+_SUB_TERMS = ["subbed", "subtitled", "subtitles", "subs"]
+
+# A pipe-delimited YouTube upload advertising a full movie, e.g.
+# "Title | English Full Movie | ...", "Title | Full Horror Movie | ...".
+_YT_FULL_MOVIE_RE = re.compile(
+    r"\bfull\s+(?:\w+\s+)?(?:movie|film|feature|length)\b", re.I
+)
+
+
+def _strip_terms(title: str, terms: list[str]) -> str:
+    """Remove bracketed and bare occurrences of ``terms`` from ``title``."""
+    pat = "|".join(terms)
+    title = re.sub(rf"\s*[\(\[\{{]\s*(?:{pat})\s*[\)\]\}}]", "", title, flags=re.I)
+    title = re.sub(rf"\s*\b(?:{pat})\b", "", title, flags=re.I)
+    return re.sub(r"\s+", " ", title).strip()
+
+
+def _pre_pipe_title(title: str) -> str | None:
+    """First segment of a pipe-delimited YouTube 'full movie' title, else None."""
+    if "|" not in title or not _YT_FULL_MOVIE_RE.search(title):
+        return None
+    return title.split("|", 1)[0].strip()
+
+
+def normalize_movie_title(raw: str, *, for_search: bool) -> tuple[str, str | None]:
+    """Return ``(clean_title, year_or_None)`` for a plain movie title.
+
+    Handles two cases the base cleaner misses:
+    - YouTube pipe titles ("Title | Full Movie | ..."): uses the first segment
+      before the pipe, but extracts the year from the *whole* string (it often
+      trails after the last pipe, e.g. "... | Larry Bucha (1961)").
+    - Dub/sub markers: ``(dubbed)`` is always removed; sub markers are removed
+      only when ``for_search`` (they stay in the display title).
+    """
+    # Year first, from the full string, so a trailing "(1961)" is captured even
+    # when the title before the pipe has none.
+    _, full_year = normalize_and_clean(raw)
+    base = _pre_pipe_title(raw) or raw
+    base = (
+        _strip_terms(base, _DUB_TERMS + _SUB_TERMS)
+        if for_search
+        else _strip_terms(base, _DUB_TERMS)
+    )
+    clean, base_year = normalize_and_clean(base)
+    return clean, base_year or full_year

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/kryten_webqueue/catalog/enrichment/pipeline.py

@@ -47,7 +47,11 @@ class CatalogEnrichmentPipeline:
 
         logger.info(
             "[enrichment] Starting pipeline: steps=%s tokens=%s force=%s dry_run=%s limit=%s",
-            steps_to_run, "specific" if tokens else "all", force, dry_run, limit
+            steps_to_run,
+            "specific" if tokens else "all",
+            force,
+            dry_run,
+            limit,
         )
 
         start = time.monotonic()
@@ -73,13 +77,15 @@ class CatalogEnrichmentPipeline:
             )
             logger.info(
                 "[enrichment] step=%s found %d item(s) (force=%s)",
-                step_name, len(rows), force
+                step_name,
+                len(rows),
+                force,
             )
             if not rows:
                 by_step[step_name] = StepResult(skipped=0)
                 continue
 
-            classifications = [self._classify_row(row) for row in rows]
+            classifications = [self._classify_row(row, force=force) for row in rows]
             total_items = max(total_items, len(classifications))
 
             if step_name == "classify":
@@ -140,14 +146,20 @@ class CatalogEnrichmentPipeline:
             by_step[step_name] = r
             logger.info(
                 "[enrichment] step=%s complete: processed=%d changed=%d skipped=%d errors=%d",
-                step_name, r.processed, r.changed, r.skipped, len(r.errors)
+                step_name,
+                r.processed,
+                r.changed,
+                r.skipped,
+                len(r.errors),
             )
             await self._report_progress(ctx, step_name, r)
 
         elapsed = time.monotonic() - start
         logger.info(
             "[enrichment] Pipeline complete in %.1fs: %d item(s), %d step(s)",
-            elapsed, total_items, len(steps_to_run)
+            elapsed,
+            total_items,
+            len(steps_to_run),
         )
 
         return EnrichmentReport(
@@ -158,12 +170,17 @@ class CatalogEnrichmentPipeline:
             dry_run=dry_run,
         )
 
-    def _classify_row(self, row: dict) -> ItemClassification:
-        """Classify a DB row, using cached enrichment state when available."""
+    def _classify_row(self, row: dict, *, force: bool = False) -> ItemClassification:
+        """Classify a DB row, using cached enrichment state when available.
+
+        ``force`` bypasses the cache and re-derives the classification from the
+        raw title so classify-logic improvements apply to already-classified
+        items.
+        """
         token = row["friendly_token"]
         # If enrichment state already has lookup_title from a prior classify run,
         # we reconstruct the classification from that cached data.
-        if row.get("content_type") and row.get("lookup_title"):
+        if not force and row.get("content_type") and row.get("lookup_title"):
             from .classify import ItemClassification, HostedInfo, HOSTED_SHOW_REGISTRY
 
             hosted: HostedInfo | None = None

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/kryten_webqueue/catalog/enrichment/steps/title.py

@@ -7,7 +7,7 @@ from datetime import datetime, UTC
 import httpx
 
 from ..classify import ItemClassification
-from ..normalise import normalize_and_clean
+from ..normalise import normalize_movie_title
 from ..report import StepResult
 
 logger = logging.getLogger(__name__)
@@ -83,7 +83,9 @@ class TitleStep:
         """Return the desired CMS title, or None if no change needed."""
         ct = cls.content_type
         if ct == "movie":
-            clean, year = normalize_and_clean(cls.raw_title)
+            # Display title keeps sub markers (dubbed is stripped); mirrors the
+            # search cleanup so pipe/YouTube titles are tidied consistently.
+            clean, year = normalize_movie_title(cls.raw_title, for_search=False)
             if year:
                 candidate = f"{clean} ({year})"
             else:
@@ -100,7 +102,6 @@ class TitleStep:
                 candidate = f"{t} - {show}"
             return candidate if candidate != cls.raw_title else None
         if ct == "riffed_movie" and cls.hosted:
-            entry_template = cls.hosted  # HostedInfo has show_name
             if "{title}" in (cls.hosted.show_name or ""):
                 return None  # template handled below
             # Only Rifftrax gets reformat; MST3K keeps original

{kryten_webqueue-0.36.5 → kryten_webqueue-0.36.7}/pyproject.toml

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