kryten-webqueue 0.36.4__tar.gz → 0.36.6__tar.gz

{kryten_webqueue-0.36.4 → kryten_webqueue-0.36.6}/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [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
+
+- **Tags step no longer reads every item.** With `mediacms_manage_all_media` set,
+  the tags step now issues a single idempotent `add_tags` POST per item (the
+  server skips tags already present) instead of a per-item `GET` to read current
+  tags/owner. The redundant per-item reverse-sync `GET` was also removed — catalog
+  sync already mirrors CMS tags in bulk via `/api/v1/media_facets`. Stock-CMS
+  (owner-scoped) deployments still do the ownership `GET` on the fallback path.
+
 ## [0.36.4] - 2026-08-14
 
 ### Changed

{kryten_webqueue-0.36.4 → kryten_webqueue-0.36.6}/PKG-INFO

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

{kryten_webqueue-0.36.4 → kryten_webqueue-0.36.6}/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.4 → kryten_webqueue-0.36.6}/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.4 → kryten_webqueue-0.36.6}/kryten_webqueue/catalog/enrichment/steps/tags.py

@@ -117,8 +117,6 @@ class TagsStep:
                             desired,
                             api_user=api_user,
                         )
-                        # Reverse sync: pull any CMS-only tags back to local DB
-                        await self._reverse_sync(client, cls.friendly_token)
                         if changed:
                             result.changed += 1
                         else:
@@ -148,50 +146,37 @@ class TagsStep:
 
         The ``PUT /media/{token}`` endpoint only accepts title/description/media_file
         and silently ignores a ``tags`` field, so tag changes must go through
-        ``POST /media/user/bulk_actions`` with ``action: add_tags``. On stock
-        MediaCMS that endpoint is owner-scoped, so unless ``manage_all`` is set we
-        skip the push for media the API user does not own rather than flooding
-        CMS with 400s.
+        ``POST /media/user/bulk_actions`` with ``action: add_tags``.
+
+        When ``manage_all`` is set the server-side ``add_tags`` is idempotent
+        (it skips tags already present), so we POST directly with no per-item GET.
+        On stock MediaCMS the endpoint is owner-scoped, so we must first GET the
+        item to check ownership and skip the push for media we do not own.
         """
-        detail_url = f"{self._base}/api/v1/media/{token}"
         try:
-            resp = await client.get(detail_url)
-            if resp.status_code != 200:
-                return False
-            data = resp.json()
-            owner = data.get("user")
-            if not self._manage_all and (api_user is None or owner != api_user):
-                return False
-            current = {
-                (t.get("title") if isinstance(t, dict) else t)
-                for t in (data.get("tags_info") or [])
-            }
-            to_add = [t for t in new_tags if t not in current]
-            if not to_add:
-                return False
+            if not self._manage_all:
+                resp = await client.get(f"{self._base}/api/v1/media/{token}")
+                if resp.status_code != 200:
+                    return False
+                data = resp.json()
+                owner = data.get("user")
+                if api_user is None or owner != api_user:
+                    return False
+                current = {
+                    (t.get("title") if isinstance(t, dict) else t)
+                    for t in (data.get("tags_info") or [])
+                }
+                new_tags = [t for t in new_tags if t not in current]
+                if not new_tags:
+                    return False
             put = await client.post(
                 f"{self._base}/api/v1/media/user/bulk_actions",
                 json={
                     "action": "add_tags",
                     "media_ids": [token],
-                    "tag_titles": to_add,
+                    "tag_titles": new_tags,
                 },
             )
             return put.status_code in (200, 201)
         except (httpx.HTTPError, json.JSONDecodeError, ValueError):
             return False
-
-    async def _reverse_sync(self, client: httpx.AsyncClient, token: str) -> None:
-        """Insert any CMS-only tags into the local catalog_tags table."""
-        url = f"{self._base}/api/v1/media/{token}"
-        try:
-            resp = await client.get(url)
-            if resp.status_code != 200:
-                return
-            data = resp.json()
-            for t in data.get("tags_info") or []:
-                name = t.get("title") if isinstance(t, dict) else t
-                if name:
-                    await self._db.add_catalog_tag(token, str(name))
-        except (httpx.HTTPError, json.JSONDecodeError, ValueError) as exc:
-            logger.warning("[tags] Failed reverse-sync for %s: %s", token, exc)

{kryten_webqueue-0.36.4 → kryten_webqueue-0.36.6}/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.4 → kryten_webqueue-0.36.6}/pyproject.toml

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