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

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

@@ -2,6 +2,42 @@
 
 ## [Unreleased]
 
+## [0.34.10] - 2026-08-13
+
+### Fixed
+
+- **Startup crash.** `app.py` referenced the now-removed `playlist_pass` key in
+  the return value of `purge_promo_hide_state()`.
+
+## [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

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

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

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/app.py

@@ -57,11 +57,10 @@ async def lifespan(app: FastAPI):
     # recently-played rules). Cheap and idempotent; also cleans rows written by
     # older builds that classified promos only by pool membership.
     purged = await db.purge_promo_hide_state()
-    if purged["completions"] or purged["playlist_pass"]:
+    if purged["completions"]:
         logger.info(
-            "Purged promo recently-played state: %d completion(s), %d pass row(s)",
+            "Purged promo recently-played state: %d completion(s)",
             purged["completions"],
-            purged["playlist_pass"],
         )
     # Any job run still marked 'running' is an orphan from a prior crash/restart
     # (the running flag is in-memory only). Reconcile before registering jobs.

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/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.7 → kryten_webqueue-0.34.10}/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(

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

@@ -63,19 +63,6 @@ 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
@@ -115,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)

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/playlists/importer.py

@@ -80,32 +80,12 @@ class PlaylistImporter:
         self._add_max_retries = add_max_retries
         self._promo_director = promo_director
 
-    async def import_playlist(
-        self, playlist_id: int, *, skip_played: bool = True
-    ) -> dict:
-        """Import items from a saved playlist into the live queue.
-
-        By default (``skip_played=True``) already-played episodes of the current
-        pass are skipped, so a mutable (TV-show) playlist continues where it left
-        off instead of replaying from the start — the same rule automated firing
-        uses. Pass ``skip_played=False`` to force-load the entire list regardless
-        of pass state.
-        """
+    async def import_playlist(self, playlist_id: int) -> dict:
+        """Import items from a saved playlist into the live queue."""
         items = await self._db.get_saved_playlist_items(playlist_id)
         if not items:
             return {"success": False, "error": "Playlist is empty"}
 
-        skipped = 0
-        if skip_played:
-            played = await self._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]
-                skipped = before - len(items)
-        if not items:
-            # Everything's already been played this pass (nothing left to add).
-            return {"success": True, "added": 0, "errors": 0, "skipped": skipped}
-
         # Suppress promo insertion for the whole load so promos aren't slotted
         # between items while the playlist is still being built.
         suppress_ctx = (
@@ -139,7 +119,7 @@ class PlaylistImporter:
                     logger.warning(f"Failed to add {item['media_id']}: {e}")
                     errors += 1
 
-        return {"success": True, "added": added, "errors": errors, "skipped": skipped}
+        return {"success": True, "added": added, "errors": errors}
 
 
 async def import_playlist_text(

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/queue/completion.py

@@ -99,3 +99,9 @@ class CompletionRecorder:
             logger.warning(
                 "Failed to record play completion for %s", token, exc_info=True
             )
+        try:
+            await self._db.rotate_playlist_item_to_bottom(token)
+        except Exception:
+            logger.warning(
+                "Failed to rotate playlist item for %s", token, exc_info=True
+            )

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/routes/admin_catalog.py

@@ -66,10 +66,8 @@ async def mark_played(
 ):
     """Simulate a genuine play-completion for an item (testing aid).
 
-    Routes through the same ``record_play_completion`` the poll loop uses, so it
-    exercises the real rules: short (<1h) episodes of a mutable playlist mark the
-    current pass (and reset it when the last item is marked), everything else
-    gets a time-boxed completion. The item then hides from regular users exactly
+    Routes through the same ``record_play_completion`` the poll loop uses.
+    The item then hides from regular users for the configured window, exactly
     as it would after real playback.
     """
     db = request.app.state.db

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/routes/admin_playlists.py

@@ -108,15 +108,9 @@ async def replace_items(
 async def import_to_live(
     request: Request,
     playlist_id: int,
-    full: int = 0,
     user: dict = Depends(require_admin),
 ):
-    """Import a saved playlist into the live CyTube queue.
-
-    By default this honors the current-pass played/skip rules (a mutable TV-show
-    playlist continues where it left off). Pass ``?full=1`` to force-load the
-    entire list regardless of what's already been played this pass.
-    """
+    """Import a saved playlist into the live CyTube queue."""
     from ..playlists.importer import PlaylistImporter
 
     db = request.app.state.db
@@ -133,7 +127,7 @@ async def import_to_live(
         add_max_retries=config.playlist_bulk_add_max_retries,
         promo_director=getattr(request.app.state, "promo_director", None),
     )
-    result = await importer.import_playlist(playlist_id, skip_played=not bool(full))
+    result = await importer.import_playlist(playlist_id)
     return result
 
 

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/static/js/admin-playlists.js

@@ -218,18 +218,13 @@ async function saveItems() {
     showToast(resp.ok ? 'Saved' : 'Save failed', resp.ok ? 'success' : 'error');
 }
 
-async function importToLive(full = false) {
+async function importToLive() {
     if (editorId === null) return;
-    const prompt = full
-        ? 'Load the ENTIRE playlist into the live CyTube queue now (ignoring what has already been played this pass)?'
-        : 'Load this playlist into the live CyTube queue now?';
-    if (!confirm(prompt)) return;
-    const url = `/admin/playlists/${editorId}/import${full ? '?full=1' : ''}`;
-    const resp = await fetch(url, {method: 'POST'});
+    if (!confirm('Load this playlist into the live CyTube queue now?')) return;
+    const resp = await fetch(`/admin/playlists/${editorId}/import`, {method: 'POST'});
     const data = await resp.json().catch(() => ({}));
     if (resp.ok && data.success) {
-        const skipped = data.skipped ? `, skipped ${data.skipped} already-played` : '';
-        showToast(`Imported ${data.added} item(s)${data.errors ? `, ${data.errors} errors` : ''}${skipped}`);
+        showToast(`Imported ${data.added} item(s)${data.errors ? `, ${data.errors} errors` : ''}`);
     } else {
         showToast(data.error || 'Import failed', 'error');
     }

{kryten_webqueue-0.34.7 → kryten_webqueue-0.34.10}/kryten_webqueue/templates/admin/playlists.html

@@ -27,8 +27,7 @@
                     <button class="btn btn-secondary" onclick="closeEditor()">&larr; Back</button>
                     <button class="btn" onclick="editMeta()">Rename</button>
                     <button class="btn btn-primary" onclick="saveItems()">Save Items</button>
-                    <button class="btn" onclick="importToLive()" title="Load this playlist into the live CyTube queue, skipping episodes already played this pass">Import to Live</button>
-                    <button class="btn" onclick="importToLive(true)" title="Load every item in this playlist into the live queue, ignoring what's already been played this pass">Load Entire List</button>
+                    <button class="btn" onclick="importToLive()" title="Load this playlist into the live CyTube queue">Import to Live</button>
                 </div>
             </div>
             <p id="editor-meta" class="muted"></p>

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

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