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

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

@@ -1,5 +1,66 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.34.9] - 2026-08-13
+
+### Changed
+
+- **Playlist continuation is now driven by rotation, not pass tracking.**
+  Replaced the broken `playlist_item_played` pass-continuation mechanism with
+  automatic playlist rotation: when an item plays past the 50% threshold,
+  `CompletionRecorder` calls `rotate_playlist_item_to_bottom`, which moves the
+  item to the end of every mutable playlist containing it. `fire_schedule` and
+  `PlaylistImporter` always load from position 0 — no filtering needed. Mutable
+  playlists now naturally advance across preemptions without ever getting stuck.
+
+- **Recently-played hiding simplified.** All played items (episodes, movies,
+  everything) now record a `play_completions` time-window row. The `playlist_item_played`
+  table is no longer written to; the "release whole collection on last item"
+  behaviour is removed. The per-item time-window applies uniformly to all catalog
+  items.
+
+- **Admin playlist UI.** "Load Entire List" button removed; "Import to Live"
+  always loads the full playlist in current order (which is the rotated order).
+
+### Removed
+
+- `get_playlist_played_media_ids` DB method
+- `skip_played` parameter from `PlaylistImporter.import_playlist`
+- `?full=1` query parameter from `POST /admin/playlists/{id}/import`
+- `by_playlist_pass` key from `GET /admin/catalog/recently-played/debug` response
+- `playlist_pass` key from `POST /admin/catalog/{token}/clear-played` response
+
+## [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.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kryten-webqueue
-Version: 0.34.4
+Version: 0.34.9
 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.9}/kryten_webqueue/catalog/db/_catalog.py

@@ -102,22 +102,13 @@ def _promo_hidden_media_subquery() -> tuple[str, list]:
 def _recently_played_exclusion(alias: str, days: int) -> tuple[str, list]:
     """SQL fragment (+ params) hiding recently-played items from regular users.
 
-    Two independent signals hide an item; either one is enough:
-
-    1. **Time window** — the item has a genuine ``play_completions`` row within
-       the last ``days`` days. A completion is only recorded when an item
-       actually played past a threshold (see ``CompletionRecorder``), so an item
-       that was queued and then refunded/removed before playing never counts.
-
-    2. **Mutable-playlist pass** — the item is a short (<1h) episode of a mutable
-       (TV-show) playlist that has played in the current pass and not yet reset
-       (``playlist_item_played``). These are governed by playlist position, not
-       the day window, so a whole show collection releases together when its last
-       item plays.
+    Items with a ``play_completions`` row within the last ``days`` days are
+    hidden. A completion is only recorded when an item played past a threshold
+    (see ``CompletionRecorder``), so refunded/skipped items never hide.
 
     The fragment is prefixed with ``AND`` so it can be appended to an existing
     WHERE clause referencing the catalog row under ``alias``. Caller must ensure
-    ``days > 0`` before applying (a non-positive window disables both signals).
+    ``days > 0`` before applying (a non-positive window disables this).
     """
     sql = f"""
             AND {alias}.friendly_token NOT IN (
@@ -125,10 +116,6 @@ def _recently_played_exclusion(alias: str, days: int) -> tuple[str, list]:
                 WHERE pc.media_type = 'cm'
                   AND pc.completed_at >= datetime('now', ?)
             )
-            AND {alias}.friendly_token NOT IN (
-                SELECT pip.media_id FROM playlist_item_played pip
-                WHERE pip.media_type = 'cm'
-            )
     """
     return sql, [f"-{int(days)} days"]
 
@@ -419,23 +406,17 @@ class _CatalogMixin:
         )
 
     async def record_play_completion(
-        self, *, friendly_token: str, duration_sec: int | None, media_type: str = "cm"
+        self,
+        *,
+        friendly_token: str,
+        duration_sec: int | None = None,
+        media_type: str = "cm",
     ) -> None:
-        """Record a genuine play-completion, routing it to the correct hide rule.
-
-        Short (<1h) episodes that belong to a mutable (TV-show) playlist are
-        governed by playlist position instead of the day window: each such
-        completion marks the episode played for the current pass, and reaching
-        the playlist's last item (MAX position) clears the whole pass so the
-        collection releases together. Everything else (movies, standalone clips,
-        long items even inside a mutable playlist) gets a time-boxed
-        ``play_completions`` row instead.
-
-        Promo-pool clips are exempt entirely: they are already excluded from the
-        public catalog and must never be treated like normal (mutable/immutable)
-        playlist items, so playing one records nothing. The same exemption covers
-        any promo/bumper hidden by category or tag (e.g. ``Z Channel Promos`` /
-        ``channelz``), which is how most station promos are actually classified.
+        """Record a genuine play-completion for catalog-hide purposes.
+
+        Promo-pool clips and hidden-category/tag items are exempt. Everything
+        else gets a time-boxed ``play_completions`` row that hides the item from
+        regular users until the configured window expires.
         """
         sub, sub_params = _promo_hidden_media_subquery()
         promo = await self._fetch_one(
@@ -444,84 +425,28 @@ class _CatalogMixin:
         )
         if promo:
             return
-        rows = await self._fetch_all(
-            """
-            SELECT spi.playlist_id AS playlist_id, spi.position AS position,
-                   (SELECT MAX(position) FROM saved_playlist_items
-                     WHERE playlist_id = spi.playlist_id) AS max_pos
-            FROM saved_playlist_items spi
-            JOIN saved_playlists sp ON sp.id = spi.playlist_id
-            WHERE spi.media_id = ? AND spi.media_type = ?
-              AND sp.is_immutable = 0 AND sp.promo_type IS NULL
-            """,
-            [friendly_token, media_type],
-        )
-        governed = False
-        if duration_sec is not None and duration_sec < 3600:
-            for r in rows:
-                governed = True
-                if r["position"] == r["max_pos"]:
-                    # Last item of the pass reached — release the whole collection.
-                    await self._execute(
-                        "DELETE FROM playlist_item_played WHERE playlist_id = ?",
-                        [r["playlist_id"]],
-                    )
-                else:
-                    await self._execute(
-                        "INSERT OR REPLACE INTO playlist_item_played "
-                        "(playlist_id, position, media_type, media_id) VALUES (?, ?, ?, ?)",
-                        [r["playlist_id"], r["position"], media_type, friendly_token],
-                    )
-        if not governed:
-            await self._execute(
-                "INSERT INTO play_completions (media_type, media_id) VALUES (?, ?)",
-                [media_type, friendly_token],
-            )
-
-    async def get_playlist_played_media_ids(self, playlist_id: int) -> set[str]:
-        """media_ids already played in the current pass of a mutable playlist.
-
-        Backed by ``playlist_item_played`` (populated only for short episodes of
-        mutable playlists and cleared when the playlist's last item plays), so
-        firing can skip already-played episodes and continue the pass instead of
-        replaying from the start.
-        """
-        rows = await self._fetch_all(
-            "SELECT media_id FROM playlist_item_played WHERE playlist_id = ?",
-            [playlist_id],
+        await self._execute(
+            "INSERT INTO play_completions (media_type, media_id) VALUES (?, ?)",
+            [media_type, friendly_token],
         )
-        return {r["media_id"] for r in rows}
 
     async def clear_play_state(
         self, friendly_token: str, *, media_type: str = "cm"
     ) -> dict:
-        """Remove all recently-played hide state for an item (admin test helper).
+        """Remove recently-played hide state for an item (admin helper).
 
-        Deletes both time-boxed ``play_completions`` rows and any
-        ``playlist_item_played`` (mutable-playlist pass) rows for the item, so it
-        immediately reappears in the public catalog. Returns the row counts
-        removed.
+        Deletes ``play_completions`` rows so the item reappears in the public
+        catalog immediately. Returns the count removed.
         """
         pc = await self._fetch_one(
             "SELECT COUNT(*) AS c FROM play_completions WHERE media_id = ? AND media_type = ?",
             [friendly_token, media_type],
         )
-        pip = await self._fetch_one(
-            "SELECT COUNT(*) AS c FROM playlist_item_played WHERE media_id = ? AND media_type = ?",
-            [friendly_token, media_type],
-        )
         await self._execute(
             "DELETE FROM play_completions WHERE media_id = ? AND media_type = ?",
             [friendly_token, media_type],
         )
-        await self._execute(
-            "DELETE FROM playlist_item_played WHERE media_id = ? AND media_type = ?",
-            [friendly_token, media_type],
-        )
-        return {
-            "completions": pc["c"] if pc else 0,
-            "playlist_pass": pip["c"] if pip else 0,
-        }
+        return {"completions": pc["c"] if pc else 0}
 
     async def purge_promo_hide_state(self) -> dict:
         """Remove any recently-played hide state recorded for promos/bumpers.
@@ -530,34 +455,20 @@ class _CatalogMixin:
         are already skipped in ``record_play_completion``; this purges rows
         written before that exemption existed (run once at startup). Covers promo
         pools plus hidden-category/tag promos (the usual station-promo case).
-        Returns the row counts removed.
+        Returns the row count removed.
         """
         sub, sub_params = _promo_hidden_media_subquery()
         pc = await self._fetch_one(
             f"SELECT COUNT(*) AS c FROM play_completions WHERE media_id IN ({sub})",
             sub_params,
         )
-        pip = await self._fetch_one(
-            f"SELECT COUNT(*) AS c FROM playlist_item_played WHERE media_id IN ({sub})",
-            sub_params,
-        )
         await self._execute(
             f"DELETE FROM play_completions WHERE media_id IN ({sub})", sub_params
         )
-        await self._execute(
-            f"DELETE FROM playlist_item_played WHERE media_id IN ({sub})", sub_params
-        )
-        return {
-            "completions": pc["c"] if pc else 0,
-            "playlist_pass": pip["c"] if pip else 0,
-        }
+        return {"completions": pc["c"] if pc else 0}
 
     async def get_recently_played_debug(self, days: int) -> dict:
-        """Snapshot of what the recently-played rules currently hide (admin test).
-
-        Mirrors the two exclusion signals used by browse/search so an admin can
-        see exactly which titles a regular user would NOT see, and why.
-        """
+        """Snapshot of what the recently-played rules currently hide (admin test)."""
         by_completion = await self._fetch_all(
             "SELECT pc.media_id, c.title, MAX(pc.completed_at) AS last_completed "
             "FROM play_completions pc "
@@ -566,17 +477,9 @@ class _CatalogMixin:
             "GROUP BY pc.media_id ORDER BY last_completed DESC",
             [f"-{int(days)} days"],
         )
-        by_playlist_pass = await self._fetch_all(
-            "SELECT pip.media_id, c.title, pip.playlist_id, sp.name AS playlist_name, pip.position "
-            "FROM playlist_item_played pip "
-            "JOIN saved_playlists sp ON sp.id = pip.playlist_id "
-            "LEFT JOIN catalog c ON c.friendly_token = pip.media_id "
-            "WHERE pip.media_type = 'cm' ORDER BY sp.name, pip.position",
-        )
         return {
             "window_days": days,
             "by_completion": by_completion,
-            "by_playlist_pass": by_playlist_pass,
         }
 
     async def get_catalog_brief(

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.9}/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.9}/kryten_webqueue/catalog/db/_playlists.py

@@ -1,3 +1,8 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
 class _PlaylistsMixin:
     """Saved playlists, promo pools, schedules, and active schedule methods."""
 
@@ -159,6 +164,72 @@ class _PlaylistsMixin:
         await self._db.commit()
         return added
 
+    async def rotate_playlist_item_to_bottom(
+        self, media_id: str, media_type: str = "cm"
+    ) -> int:
+        """Move a played item to the end of every mutable playlist containing it.
+
+        Played items sink to the bottom so the next fire always loads the
+        oldest-played item last. Idempotent when the item is already at
+        MAX(position). Returns the number of playlists rotated.
+        """
+        playlists = await self._fetch_all(
+            """
+            SELECT spi.playlist_id
+            FROM saved_playlist_items spi
+            JOIN saved_playlists sp ON sp.id = spi.playlist_id
+            WHERE spi.media_id = ? AND spi.media_type = ?
+              AND sp.is_immutable = 0 AND sp.promo_type IS NULL
+            """,
+            [media_id, media_type],
+        )
+        rotated = 0
+        for r in playlists:
+            playlist_id = r["playlist_id"]
+            items = await self._fetch_all(
+                "SELECT * FROM saved_playlist_items WHERE playlist_id = ? ORDER BY position",
+                [playlist_id],
+            )
+            target_idx = next(
+                (
+                    i
+                    for i, it in enumerate(items)
+                    if it["media_id"] == media_id and it["media_type"] == media_type
+                ),
+                None,
+            )
+            if target_idx is None or target_idx == len(items) - 1:
+                continue  # not found or already at bottom
+            # Move target to end; delete-then-reinsert avoids position UNIQUE conflicts.
+            reordered = (
+                items[:target_idx] + items[target_idx + 1 :] + [items[target_idx]]
+            )
+            await self._db.execute(
+                "DELETE FROM saved_playlist_items WHERE playlist_id=?", [playlist_id]
+            )
+            for new_pos, item in enumerate(reordered):
+                await self._db.execute(
+                    "INSERT INTO saved_playlist_items "
+                    "(playlist_id, position, media_type, media_id, title, duration_sec) "
+                    "VALUES (?, ?, ?, ?, ?, ?)",
+                    [
+                        playlist_id,
+                        new_pos,
+                        item["media_type"],
+                        item["media_id"],
+                        item.get("title"),
+                        item.get("duration_sec"),
+                    ],
+                )
+            await self._db.execute(
+                "UPDATE saved_playlists SET updated_at=datetime('now') WHERE id=?",
+                [playlist_id],
+            )
+            await self._db.commit()
+            logger.info("Rotated %r to bottom of playlist %d", media_id, playlist_id)
+            rotated += 1
+        return rotated
+
     async def get_most_recent_playlist(self, created_by: str) -> dict | None:
         """The given admin's most recently *created* saved playlist, if any."""
         return await self._fetch_one(
@@ -242,11 +313,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 +327,7 @@ class _PlaylistsMixin:
                 started_at,
                 estimated_end_at,
                 last_item_uid,
+                last_item_media_id,
             ],
         )
 

{kryten_webqueue-0.34.4 → kryten_webqueue-0.34.9}/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.9}/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.9}/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.9}/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.9}/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.9}/kryten_webqueue/playlists/fire.py

@@ -63,21 +63,9 @@ async def fire_schedule(
 
             # Load scheduled playlist items
             items = await db.get_saved_playlist_items(playlist_id)
-            # For a mutable (TV-show) playlist, skip episodes already played in the
-            # current pass so a re-fire continues where it left off instead of
-            # replaying season 1. Immutable/promo playlists never have played rows,
-            # so this is a no-op for them.
-            played = await db.get_playlist_played_media_ids(playlist_id)
-            if played:
-                before = len(items)
-                items = [it for it in items if it["media_id"] not in played]
-                if before != len(items):
-                    logger.info(
-                        f"Schedule {schedule_id}: skipped {before - len(items)} already-played "
-                        f"episode(s) from mutable playlist {playlist_id}"
-                    )
             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 +85,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(
@@ -111,13 +102,6 @@ async def fire_schedule(
             fallback_id = schedule.get("fallback_playlist_id")
             if fallback_id:
                 fallback_items = await db.get_saved_playlist_items(fallback_id)
-                # Same continuation logic as the main playlist: skip already-played
-                # episodes of the (mutable) fallback so it advances across fires.
-                fb_played = await db.get_playlist_played_media_ids(fallback_id)
-                if fb_played:
-                    fallback_items = [
-                        it for it in fallback_items if it["media_id"] not in fb_played
-                    ]
                 for index, item in enumerate(fallback_items):
                     if index and add_delay_sec:
                         await asyncio.sleep(add_delay_sec)
@@ -150,6 +134,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