kryten-webqueue 0.34.4__tar.gz → 0.34.7__tar.gz

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.34.7] - 2026-08-13
+
+### Fixed
+
+- **Event lock lifts at the correct time (Bug #1).** The scheduled-event
+  pay-to-play lock was lifting ~30 minutes late when `last_item_uid` was never
+  captured (e.g. a CyTube `queue`-event timeout during bulk add left the field
+  `NULL`). With no uid anchor `_maybe_lift_event_lock` returned early and the
+  only fallback was the `estimated_end_at + 5 min` time safety net, which fires
+  roughly when the *last* item finishes rather than when it *starts*.
+  Fix: `fire_schedule` now always records `last_item_media_id` (the manifest
+  URL of the last scheduled item) even when the uid is unavailable. The lock
+  lift logic now matches on `media_id` first and falls back to `last_item_uid`,
+  so pay-to-play reopens as soon as the last scheduled item begins playing
+  regardless of whether the uid was captured. DB migration v12 adds the new
+  `last_item_media_id TEXT` column to `active_schedule`.
+
+- **Schedule modifications apply immediately (Bug #2).** When a schedule was
+  updated via the admin UI, the APScheduler job was re-registered only if
+  `fire_at` was present in the request body. The `update_schedule` route now
+  always re-registers the job after any modification, and it reads the
+  authoritative `fire_at` from the database (not from the request body) to
+  avoid stale or mismatched values. If the updated `fire_at` is already in the
+  past, the job is not re-armed (preventing an accidental immediate re-fire).
+
+- Cover art downloads for movies: corrected TMDB API parameter from `year` to
+  `primary_release_year` in movie search. TV searches already used the correct
+  `first_air_date_year` parameter, which is why cover art worked for TV but
+  not movies.
+
 ## [0.34.4] - 2026-08-12
 
 ### Changed

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/PKG-INFO

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

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/catalog/db/_connection.py

@@ -227,7 +227,14 @@ MIGRATIONS = [
     ALTER TABLE queue_shadow ADD COLUMN promo_type TEXT;
     ALTER TABLE queue_shadow ADD COLUMN lead_in_for_uid INTEGER;
     """,
-    # v12: Viewer feedback + movie-title suggestions, each with a simple
+    # v12: Media-id fallback for the event-lock auto-lift. Stores the media_id
+    # of the last scheduled item so _maybe_lift_event_lock can detect when it
+    # begins playing even when last_item_uid was never captured (e.g. a CyTube
+    # queue-event timeout during bulk add left the uid null).
+    """
+    ALTER TABLE active_schedule ADD COLUMN last_item_media_id TEXT;
+    """,
+    # v13: Viewer feedback + movie-title suggestions, each with a simple
     # admin-triage queue (status new|read). Title suggestions record the
     # resolved match against TMDB/OMDB (NULL when unresolved) and whether we
     # already have the title in the catalog (resolution + catalog_token).
@@ -257,7 +264,7 @@ MIGRATIONS = [
     );
     CREATE INDEX IF NOT EXISTS idx_title_suggestions_status ON title_suggestions(status, created_at);
     """,
-    # v13: Play-completion tracking that drives hiding recently-played catalog
+    # v14: Play-completion tracking that drives hiding recently-played catalog
     # items from regular users.
     #
     # play_completions records a *genuine* completion (an item that reached the
@@ -290,7 +297,7 @@ MIGRATIONS = [
     );
     CREATE INDEX IF NOT EXISTS idx_playlist_item_played_media ON playlist_item_played(media_id);
     """,
-    # v14: One-time cleanup of recently-played hide state wrongly recorded for
+    # v15: One-time cleanup of recently-played hide state wrongly recorded for
     # promo-pool clips. Promos are excluded from the public catalog and must
     # never be treated like normal playlist items, so any hide state recorded for
     # a promo clip (before the exemption in record_play_completion) is purged.
@@ -308,7 +315,7 @@ MIGRATIONS = [
         WHERE sp.promo_type IS NOT NULL AND spi.media_type = 'cm'
     );
     """,
-    # v15: Cron-based job schedule persistence (separate from playlist_schedules,
+    # v16: Cron-based job schedule persistence (separate from playlist_schedules,
     # which fires playlists onto the queue). One row per job; UNIQUE on job_name.
     # run_next_job chains another job to run immediately after this one completes.
     """

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/catalog/db/_playlists.py

@@ -242,11 +242,13 @@ class _PlaylistsMixin:
         started_at: str,
         estimated_end_at: str,
         last_item_uid: int | None = None,
+        last_item_media_id: str | None = None,
     ):
         await self._execute(
             "INSERT OR REPLACE INTO active_schedule "
-            "(id, schedule_id, playlist_id, is_immutable, started_at, estimated_end_at, last_item_uid, lock_disabled) "
-            "VALUES (1, ?, ?, ?, ?, ?, ?, 0)",
+            "(id, schedule_id, playlist_id, is_immutable, started_at, estimated_end_at, "
+            "last_item_uid, last_item_media_id, lock_disabled) "
+            "VALUES (1, ?, ?, ?, ?, ?, ?, ?, 0)",
             [
                 schedule_id,
                 playlist_id,
@@ -254,6 +256,7 @@ class _PlaylistsMixin:
                 started_at,
                 estimated_end_at,
                 last_item_uid,
+                last_item_media_id,
             ],
         )
 

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/catalog/images.py

@@ -180,7 +180,7 @@ class CoverArtResolver:
         """Search a specific TMDB media type. Returns (poster_url_or_None, popularity)."""
         params: dict = {"api_key": self._tmdb_key, "query": title}
         if year and media_type == "movie":
-            params["year"] = year
+            params["primary_release_year"] = year
         elif year and media_type == "tv":
             params["first_air_date_year"] = year
         try:

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/integrations/cmsutils/fetchurls.py

@@ -1627,7 +1627,9 @@ def run(params: dict, *, config, progress=None) -> dict:
                 dry_run=dry_run,
                 progress=_emit,
             )
-        except Exception as _pm_exc:  # noqa: BLE001 - non-fatal; keep fetchurls result intact
+        except (
+            Exception
+        ) as _pm_exc:  # noqa: BLE001 - non-fatal; keep fetchurls result intact
             logger.warning("played_movies sync failed: %s", _pm_exc, exc_info=True)
 
     _emit(

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/integrations/cmsutils/motdposters.py

@@ -210,7 +210,9 @@ def _pick_placeholder(placeholder_dir: str) -> bytes | None:
     p = Path(placeholder_dir).expanduser()
     if not p.is_dir():
         return None
-    candidates = [f for f in p.iterdir() if f.is_file() and f.suffix.lower() in _IMAGE_EXTS]
+    candidates = [
+        f for f in p.iterdir() if f.is_file() and f.suffix.lower() in _IMAGE_EXTS
+    ]
     if not candidates:
         return None
     return random.choice(candidates).read_bytes()
@@ -239,7 +241,11 @@ def _generate_html(night_entries: list[dict], poster_base_url: str) -> str:
 
         img_url = f"{base}/{entry['filename']}"
         imdb_id = entry.get("imdb_id") or ""
-        href = f"https://www.imdb.com/title/{imdb_id}/" if imdb_id else "https://www.imdb.com/"
+        href = (
+            f"https://www.imdb.com/title/{imdb_id}/"
+            if imdb_id
+            else "https://www.imdb.com/"
+        )
 
         lines.append(
             f'    <a href="{escape(href)}" target="_blank" rel="noopener noreferrer">'
@@ -393,7 +399,10 @@ def run(params: dict, *, config, progress=None) -> dict:
             entry["imdb_id"] = info["imdb_id"]
             if dry_run:
                 logger.info(
-                    "motd_posters [dry-run]: %s → %s (%s)", title, info["imdb_id"], filename
+                    "motd_posters [dry-run]: %s → %s (%s)",
+                    title,
+                    info["imdb_id"],
+                    filename,
                 )
                 resolved += 1
             else:
@@ -431,7 +440,9 @@ def run(params: dict, *, config, progress=None) -> dict:
     output_path = output_dir / f"motd-{sheet_name}.html"
 
     if dry_run:
-        logger.info("motd_posters [dry-run]: HTML snippet (not written):\n%s", html_snippet)
+        logger.info(
+            "motd_posters [dry-run]: HTML snippet (not written):\n%s", html_snippet
+        )
     else:
         output_path.write_text(html_snippet, encoding="utf-8")
         logger.info("motd_posters: wrote HTML snippet → %s", output_path)

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/integrations/cmsutils/playedmovies.py

@@ -161,7 +161,10 @@ def _write_rows(
 
         sess_resp = requests.post(
             f"{wb_base}/createSession",
-            headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            },
             data=json.dumps({"persistChanges": True}),
             timeout=WRITEBACK_TIMEOUT,
         )
@@ -169,7 +172,10 @@ def _write_rows(
         if sess_resp.status_code in (200, 201):
             sid = sess_resp.json().get("id", "")
 
-        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
         if sid:
             headers["workbook-session-id"] = sid
 
@@ -261,7 +267,13 @@ def sync_played_movies(
 
     if not new_rows:
         logger.info("played_movies: all %d movie(s) already recorded", len(movies))
-        return {"found": len(movies), "added": 0, "skipped": skipped, "failed": 0, "dry_run": dry_run}
+        return {
+            "found": len(movies),
+            "added": 0,
+            "skipped": skipped,
+            "failed": 0,
+            "dry_run": dry_run,
+        }
 
     start_row = last_played_row(wb_bytes) + 1
 
@@ -282,7 +294,9 @@ def sync_played_movies(
     if progress:
         progress({"phase": "played_movies_write", "count": len(new_rows)})
 
-    ok, fail = _write_rows(graph_token, drive_id, item_id, new_rows, start_row, progress=progress)
+    ok, fail = _write_rows(
+        graph_token, drive_id, item_id, new_rows, start_row, progress=progress
+    )
     logger.info(
         "played_movies: added %d/%d, skipped %d, failed %d",
         ok,

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/jobs/job_scheduler.py

@@ -68,7 +68,10 @@ class JobScheduler:
                 id=f"jsch_{job_name}",
                 replace_existing=True,
             )
-        except (ValueError, Exception) as exc:  # noqa: BLE001 - bad stored cron must not crash startup
+        except (
+            ValueError,
+            Exception,
+        ) as exc:  # noqa: BLE001 - bad stored cron must not crash startup
             logger.warning(
                 "JobScheduler: skipping invalid cron %r for %r: %s",
                 cron_expression,
@@ -125,11 +128,17 @@ class JobScheduler:
             minute, hour, day, month, day_of_week = parts
             try:
                 CronTrigger(
-                    minute=minute, hour=hour, day=day,
-                    month=month, day_of_week=day_of_week, timezone="UTC",
+                    minute=minute,
+                    hour=hour,
+                    day=day,
+                    month=month,
+                    day_of_week=day_of_week,
+                    timezone="UTC",
                 )
             except Exception as exc:
-                raise ValueError(f"Invalid cron expression {cron_expression!r}: {exc}") from exc
+                raise ValueError(
+                    f"Invalid cron expression {cron_expression!r}: {exc}"
+                ) from exc
 
         params_json = json.dumps(params) if params is not None else None
         await self._db.upsert_job_schedule(

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/playlists/fire.py

@@ -78,6 +78,7 @@ async def fire_schedule(
                     )
             total_duration = 0
             last_item_uid = None
+            last_item_media_id = None
             for index, item in enumerate(items):
                 # Throttle consecutive adds so CyTube can validate each item before
                 # the next arrives (avoids transient queueFail/422 under load).
@@ -97,6 +98,9 @@ async def fire_schedule(
                         and add_result.get("uid") is not None
                     ):
                         last_item_uid = add_result["uid"]
+                    # Always track the last scheduled item's media_id so the
+                    # event-lock can lift even when the uid was not captured.
+                    last_item_media_id = item.get("media_id")
                     total_duration += item.get("duration_sec", 0) or 0
                 except Exception as e:
                     logger.warning(
@@ -150,6 +154,7 @@ async def fire_schedule(
                 started_at=now.isoformat(),
                 estimated_end_at=(now + timedelta(seconds=total_duration)).isoformat(),
                 last_item_uid=last_item_uid,
+                last_item_media_id=last_item_media_id,
             )
 
             # Mark schedule as fired

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/queue/shadow.py

@@ -147,25 +147,44 @@ class QueueShadow:
         scheduled fire, the curated event is effectively over (only the final
         item remains), so pay-to-play should reopen for content that plays after
         it. Idempotent: a no-op once the lock is already lifted.
+
+        Matching uses two anchors in priority order:
+        1. ``last_item_uid`` — the CyTube playlist uid assigned at add time.
+           Most reliable when the bot hasn't reconnected between fire and now.
+        2. ``last_item_media_id`` — the media id (manifest URL) of the last
+           scheduled item, tracked even when the uid was never captured (e.g.
+           the CyTube ``queue`` event timed out in the robot during bulk add).
         """
         active = await self._db.get_active_schedule()
         if not active or active.get("lock_disabled"):
             return
         last_uid = active.get("last_item_uid")
-        if last_uid is None:
+        last_media_id = active.get("last_item_media_id")
+        if last_uid is None and last_media_id is None:
             return
         idx = self._now_playing_index()
         if idx is None:
             return
-        cur_uid = self._items[idx].get("uid")
+        cur_item = self._items[idx]
+        cur_uid = cur_item.get("uid")
+        cur_media_id = cur_item.get("media_id")
         try:
-            if cur_uid is not None and int(cur_uid) == int(last_uid):
-                await self._db.disable_active_lock()
-                logger.info(
-                    "Scheduled-event lock lifted: last scheduled item now playing"
-                )
+            uid_match = (
+                last_uid is not None
+                and cur_uid is not None
+                and int(cur_uid) == int(last_uid)
+            )
         except (TypeError, ValueError):
-            return
+            uid_match = False
+        media_match = last_media_id is not None and cur_media_id == last_media_id
+        if uid_match or media_match:
+            await self._db.disable_active_lock()
+            logger.info(
+                "Scheduled-event lock lifted: last scheduled item now playing"
+                " (uid_match=%s media_match=%s)",
+                uid_match,
+                media_match,
+            )
 
     async def _maybe_expire_active_schedule(self):
         """Clear the active-schedule row once the event is genuinely over.

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/routes/admin_job_schedules.py

@@ -37,7 +37,9 @@ async def upsert_job_schedule(request: Request, user: dict = Depends(require_adm
     if not cron_expression:
         raise HTTPException(400, "cron_expression is required")
     if len(cron_expression.split()) != 5:
-        raise HTTPException(400, "cron_expression must have exactly 5 fields (min hour dom mon dow)")
+        raise HTTPException(
+            400, "cron_expression must have exactly 5 fields (min hour dom mon dow)"
+        )
 
     job_scheduler = request.app.state.job_scheduler
     try:
@@ -64,7 +66,9 @@ async def update_job_schedule(
     if not cron_expression:
         raise HTTPException(400, "cron_expression is required")
     if len(cron_expression.split()) != 5:
-        raise HTTPException(400, "cron_expression must have exactly 5 fields (min hour dom mon dow)")
+        raise HTTPException(
+            400, "cron_expression must have exactly 5 fields (min hour dom mon dow)"
+        )
 
     job_scheduler = request.app.state.job_scheduler
     try:

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/kryten_webqueue/routes/admin_schedules.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, Request, Depends, HTTPException
-from datetime import datetime
+from datetime import datetime, UTC
 
 from ..auth.session import require_admin
 
@@ -71,7 +71,13 @@ async def create_schedule(request: Request, user: dict = Depends(require_admin))
 async def update_schedule(
     request: Request, schedule_id: int, user: dict = Depends(require_admin)
 ):
-    """Update a schedule."""
+    """Update a schedule.
+
+    Always re-registers the APScheduler job from the authoritative DB value
+    after the update, regardless of which fields changed. This ensures that
+    modifications made close to the fire time (including playlist-only changes)
+    take effect for the immediate scheduled item.
+    """
     body = await request.json()
     db = request.app.state.db
     scheduler = request.app.state.scheduler
@@ -82,11 +88,15 @@ async def update_schedule(
 
     await db.update_schedule(schedule_id, **body)
 
-    # Re-register if fire_at changed
-    if "fire_at" in body:
-        await scheduler.remove_schedule(schedule_id)
-        fire_at = datetime.fromisoformat(body["fire_at"])
-        await scheduler.add_schedule(schedule_id, fire_at)
+    # Re-read from DB so the scheduler always uses the authoritative fire_at
+    # (not the body value, which may differ due to serialization or race with
+    # a recurring re-arm). Only arm a future job; past schedules won't re-fire.
+    updated = await db.get_schedule(schedule_id)
+    await scheduler.remove_schedule(schedule_id)
+    if updated and updated.get("is_active"):
+        fire_at = scheduler._parse_fire_at(updated["fire_at"])
+        if fire_at > datetime.now(UTC):
+            await scheduler.add_schedule(schedule_id, fire_at)
 
     return {"success": True}
 

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/pyproject.toml

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

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.7}/tests/test_phase4_live_fixes.py

@@ -338,3 +338,135 @@ async def test_fire_without_fallback_only_adds_event(db):
         schedule_id=sid, api_gate=api, db=db, shadow=shadow, ws_manager=_FakeWs()
     )
     assert [a["media_id"] for a in api.added] == ["e1"]
+
+
+# --- Bug #1 regression: media_id fallback for event-lock lift ---
+
+
+async def test_event_lock_lifts_via_media_id_when_uid_absent(db):
+    """Lock lifts when now-playing matches last_item_media_id, even if
+    last_item_uid is None (uid not captured during bulk add)."""
+    pid = await db.create_saved_playlist(
+        name="E", description=None, is_immutable=True, created_by="admin"
+    )
+    sid = await db.create_schedule(
+        playlist_id=pid,
+        label="E",
+        fire_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S"),
+        is_active=1,
+        created_by="admin",
+    )
+    now = datetime.now(UTC)
+    await db.set_active_schedule(
+        schedule_id=sid,
+        playlist_id=pid,
+        is_immutable=True,
+        started_at=now.isoformat(),
+        estimated_end_at=(now + timedelta(hours=1)).isoformat(),
+        last_item_uid=None,  # uid never captured
+        last_item_media_id="https://cms.example/media/last.json",
+    )
+    assert await db.is_event_lock_active() is True
+
+    shadow = QueueShadow(db)
+    # now_playing has no uid — CyTube's changeMedia payload — only id/type.
+    items = [_polled(1), _polled(2)]
+    # Override the second item's media_id to match last_item_media_id.
+    items[1] = {
+        "uid": 2,
+        "queueby": None,
+        "media": {
+            "id": "https://cms.example/media/last.json",
+            "type": "cm",
+            "title": "Last Item",
+            "seconds": 100,
+        },
+    }
+    np_no_uid = {
+        "id": "https://cms.example/media/last.json",
+        "type": "cm",
+        "seconds": 100,
+        "currentTime": 0,
+    }
+    await shadow.apply_poll_result(items, np_no_uid)
+    assert await db.is_event_lock_active() is False
+
+
+async def test_event_lock_stays_when_earlier_item_plays_by_media_id(db):
+    """Lock must NOT lift when an earlier item (not the last) is playing."""
+    pid = await db.create_saved_playlist(
+        name="E", description=None, is_immutable=True, created_by="admin"
+    )
+    sid = await db.create_schedule(
+        playlist_id=pid,
+        label="E",
+        fire_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S"),
+        is_active=1,
+        created_by="admin",
+    )
+    now = datetime.now(UTC)
+    await db.set_active_schedule(
+        schedule_id=sid,
+        playlist_id=pid,
+        is_immutable=True,
+        started_at=now.isoformat(),
+        estimated_end_at=(now + timedelta(hours=1)).isoformat(),
+        last_item_uid=None,
+        last_item_media_id="https://cms.example/media/last.json",
+    )
+    shadow = QueueShadow(db)
+    items = [_polled(1), _polled(2)]
+    items[1] = {
+        "uid": 2,
+        "queueby": None,
+        "media": {
+            "id": "https://cms.example/media/last.json",
+            "type": "cm",
+            "title": "Last",
+            "seconds": 100,
+        },
+    }
+    # Earlier item (uid=1 / id=m1) is playing — lock must stay on.
+    np_earlier = {"id": "m1", "type": "cm", "seconds": 100, "currentTime": 0}
+    await shadow.apply_poll_result(items, np_earlier)
+    assert await db.is_event_lock_active() is True
+
+
+async def test_fire_stores_last_item_media_id(db):
+    """fire_schedule must store last_item_media_id on the active_schedule row."""
+    from kryten_webqueue.playlists.fire import fire_schedule
+
+    pid = await db.create_saved_playlist(
+        name="Event", description=None, is_immutable=True, created_by="admin"
+    )
+    await db.replace_playlist_items(
+        pid,
+        [
+            {
+                "media_type": "cm",
+                "media_id": "https://cms/a.json",
+                "title": "A",
+                "duration_sec": 60,
+            },
+            {
+                "media_type": "cm",
+                "media_id": "https://cms/b.json",
+                "title": "B",
+                "duration_sec": 60,
+            },
+        ],
+    )
+    sid = await db.create_schedule(
+        playlist_id=pid,
+        label="Test",
+        fire_at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S"),
+        is_active=1,
+        created_by="admin",
+    )
+    api = _FakeApiGate()
+    shadow = QueueShadow(db)
+    await fire_schedule(
+        schedule_id=sid, api_gate=api, db=db, shadow=shadow, ws_manager=_FakeWs()
+    )
+    active = await db.get_active_schedule()
+    assert active["last_item_media_id"] == "https://cms/b.json"