kryten-webqueue 0.36.1__tar.gz → 0.36.3__tar.gz

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.36.3] - 2026-08-14
+
+### Added
+
+- **`mediacms_manage_all_media` config flag.** When set (paired with a CMS whose
+  `bulk_actions` is patched to let managers/superusers tag any media), the tags
+  step pushes derived genre/MPAA/hosted tags to CMS for every item, not just
+  media the API user owns. Defaults to `false` (owner-only, safe).
+
+### Changed
+
+- **MPAA rating tags are now alphanumeric** (`mpaar`, `mpaapg13`, …) to match
+  MediaCMS's `Tag.save()` normalization (which strips non-alphanumerics), so tags
+  round-trip cleanly between the local catalog and CMS without creating hyphenated
+  duplicates on reverse-sync.
+
+## [0.36.2] - 2026-08-14
+
+### Fixed
+
+- **Stop flooding MediaCMS with futile tag-push 400s.** The tags step attempted
+  `POST /media/user/bulk_actions` (`add_tags`) for every enriched item, but that
+  endpoint filters `Media.objects.filter(user=request.user, ...)` with no manager
+  or superuser bypass, so pushes against media owned by other users always return
+  400 "No matching media found". The step now looks up the API token's username
+  once via `/whoami` and only attempts the CMS push for media that user actually
+  owns. Local `catalog_tags` remains the source of truth for derived
+  genre/MPAA/hosted tags, so tags still display regardless.
+
 ## [0.36.1] - 2026-08-14
 
 ### Fixed

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/PKG-INFO

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

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/config.example.json

@@ -13,6 +13,7 @@
 
   "mediacms_url": "https://www.dropsugar.com",
   "mediacms_token": "CHANGE_ME",
+  "mediacms_manage_all_media": false,
 
   "tmdb_api_key": "",
   "omdb_api_key": "",

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/kryten_webqueue/catalog/enrichment/steps/tags.py

@@ -18,15 +18,15 @@ _TIMEOUT = 20.0
 _MPAA = frozenset({"G", "PG", "PG-13", "R", "NC-17", "NR", "TV-MA", "TV-14", "TV-PG"})
 
 _MPAA_SLUG = {
-    "G": "mpaa-g",
-    "PG": "mpaa-pg",
-    "PG-13": "mpaa-pg13",
-    "R": "mpaa-r",
-    "NC-17": "mpaa-nc17",
-    "NR": "mpaa-nr",
-    "TV-MA": "mpaa-tvma",
-    "TV-14": "mpaa-tv14",
-    "TV-PG": "mpaa-tvpg",
+    "G": "mpaag",
+    "PG": "mpaapg",
+    "PG-13": "mpaapg13",
+    "R": "mpaar",
+    "NC-17": "mpaanc17",
+    "NR": "mpaanr",
+    "TV-MA": "mpaatvma",
+    "TV-14": "mpaatv14",
+    "TV-PG": "mpaatvpg",
 }
 
 
@@ -41,6 +41,25 @@ class TagsStep:
             config.mediacms_url.rstrip("/").removesuffix("/api/v1").removesuffix("/api")
         )
         self._headers = {"Authorization": f"Token {config.mediacms_token}"}
+        # When the token can manage all media (e.g. a manager/superuser on a
+        # patched CMS), push tags for every item instead of only owned media.
+        self._manage_all = bool(getattr(config, "mediacms_manage_all_media", False))
+
+    async def _get_api_username(self, client: httpx.AsyncClient) -> str | None:
+        """Return the API token's username, or None.
+
+        Stock MediaCMS ``/media/user/bulk_actions`` filters ``Media.objects.filter(
+        user=request.user, ...)``, so tag pushes only succeed on media this user
+        owns. When ``mediacms_manage_all_media`` is not set we use this to skip
+        futile pushes against media owned by others instead of flooding CMS.
+        """
+        try:
+            resp = await client.get(f"{self._base}/api/v1/whoami")
+            if resp.status_code != 200:
+                return None
+            return resp.json().get("username")
+        except (httpx.HTTPError, json.JSONDecodeError, ValueError):
+            return None
 
     async def run(
         self,
@@ -54,6 +73,11 @@ class TagsStep:
         now = datetime.now(UTC).isoformat()
 
         async with httpx.AsyncClient(headers=self._headers, timeout=_TIMEOUT) as client:
+            api_user = (
+                None
+                if dry_run or self._manage_all
+                else await self._get_api_username(client)
+            )
             for cls in classifications:
                 result.processed += 1
                 try:
@@ -88,7 +112,10 @@ class TagsStep:
                         for tag in desired:
                             await self._db.add_catalog_tag(cls.friendly_token, tag)
                         changed = await self._push_tags(
-                            client, cls.friendly_token, desired
+                            client,
+                            cls.friendly_token,
+                            desired,
+                            api_user=api_user,
                         )
                         # Reverse sync: pull any CMS-only tags back to local DB
                         await self._reverse_sync(client, cls.friendly_token)
@@ -110,13 +137,21 @@ class TagsStep:
         return result
 
     async def _push_tags(
-        self, client: httpx.AsyncClient, token: str, new_tags: list[str]
+        self,
+        client: httpx.AsyncClient,
+        token: str,
+        new_tags: list[str],
+        *,
+        api_user: str | None = None,
     ) -> bool:
         """Add tags to a CMS media item via the bulk_actions ``add_tags`` action.
 
         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``.
+        ``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.
         """
         detail_url = f"{self._base}/api/v1/media/{token}"
         try:
@@ -124,6 +159,9 @@ class TagsStep:
             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 [])

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/kryten_webqueue/config.py

@@ -151,6 +151,9 @@ class Config(BaseModel):
     # MediaCMS
     mediacms_url: str = "https://www.dropsugar.com"
     mediacms_token: str
+    # Set true when the token can tag any media (manager/superuser on a CMS whose
+    # bulk_actions is patched to allow it); pushes derived tags for all items.
+    mediacms_manage_all_media: bool = False
 
     # Cover art APIs
     tmdb_api_key: str = ""

{kryten_webqueue-0.36.1 → kryten_webqueue-0.36.3}/pyproject.toml

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

kryten_webqueue-0.36.3/scripts/patch_mediacms_tags.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Patch MediaCMS MediaBulkUserActions so editors/superusers can tag any media,
+and add_tags creates missing tags (normalized like Tag.save)."""
+
+import sys
+
+PATH = "/home/mediacms.io/mediacms/files/views/media.py"
+
+QS_OLD = (
+    "        media = Media.objects.filter(user=request.user, friendly_token__in=media_ids)\n"
+)
+QS_NEW = (
+    "        if is_mediacms_editor(request.user):\n"
+    "            media = Media.objects.filter(friendly_token__in=media_ids)\n"
+    "        else:\n"
+    "            media = Media.objects.filter(user=request.user, friendly_token__in=media_ids)\n"
+)
+
+TAGS_OLD = (
+    '        elif action == "add_tags":\n'
+    "            tag_titles = request.data.get('tag_titles', [])\n"
+    "            if not tag_titles:\n"
+    '                return Response({"detail": "tag_titles is required for add_tags action"}, status=status.HTTP_400_BAD_REQUEST)\n'
+    "\n"
+    "            tags = Tag.objects.filter(title__in=tag_titles)\n"
+    "            if not tags:\n"
+    '                return Response({"detail": "No matching tags found"}, status=status.HTTP_400_BAD_REQUEST)\n'
+    "\n"
+    "            added_count = 0\n"
+    "            for tag in tags:\n"
+    "                for m in media:\n"
+    "                    if not m.tags.filter(title=tag.title).exists():\n"
+    "                        m.tags.add(tag)\n"
+    "                        added_count += 1\n"
+    "\n"
+    '            return Response({"detail": f"Added {added_count} media items to {tags.count()} tags"})\n'
+)
+TAGS_NEW = (
+    '        elif action == "add_tags":\n'
+    "            tag_titles = request.data.get('tag_titles', [])\n"
+    "            if not tag_titles:\n"
+    '                return Response({"detail": "tag_titles is required for add_tags action"}, status=status.HTTP_400_BAD_REQUEST)\n'
+    "\n"
+    "            tags = []\n"
+    "            for raw in tag_titles:\n"
+    "                title = helpers.get_alphanumeric_only(raw)[:100]\n"
+    "                if not title:\n"
+    "                    continue\n"
+    "                tag, _ = Tag.objects.get_or_create(title=title, defaults={\"user\": request.user})\n"
+    "                tags.append(tag)\n"
+    "            if not tags:\n"
+    '                return Response({"detail": "No matching tags found"}, status=status.HTTP_400_BAD_REQUEST)\n'
+    "\n"
+    "            added_count = 0\n"
+    "            for tag in tags:\n"
+    "                for m in media:\n"
+    "                    if not m.tags.filter(title=tag.title).exists():\n"
+    "                        m.tags.add(tag)\n"
+    "                        added_count += 1\n"
+    "\n"
+    '            return Response({"detail": f"Added {added_count} media items to {len(tags)} tags"})\n'
+)
+
+
+def main() -> int:
+    with open(PATH, encoding="utf-8") as f:
+        src = f.read()
+
+    if QS_NEW in src and TAGS_NEW in src:
+        print("Already patched; nothing to do.")
+        return 0
+
+    if src.count(QS_OLD) != 1:
+        print(f"ERROR: queryset anchor found {src.count(QS_OLD)} times (expected 1)")
+        return 2
+    if src.count(TAGS_OLD) != 1:
+        print(f"ERROR: add_tags anchor found {src.count(TAGS_OLD)} times (expected 1)")
+        return 3
+
+    src = src.replace(QS_OLD, QS_NEW, 1)
+    src = src.replace(TAGS_OLD, TAGS_NEW, 1)
+
+    with open(PATH, "w", encoding="utf-8") as f:
+        f.write(src)
+    print("Patched OK.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())