kryten-webqueue 0.9.2__tar.gz → 0.9.3__tar.gz

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
+## [0.9.3] — 2026-06-11
+
+### Fixed
+
+- **Queue ETAs are computed from the remainder of the *currently-playing* item and wrap around the playlist.** Previously the schedule was built as if the item at list index 0 always played next, so whenever the now-playing item was not at the head, every ETA was wrong. ETAs now start from the time left on the current item and walk the rest of the list in true play order (item after current → end → wrap to the front), matching CyTube's looping playlist.
+- **Paid items keep their purchase order (FIFO).** New paid items were being anchored against a stale `queue_shadow.position` read from the DB (poll reconciliation only re-indexed positions in memory), which could drop every new item directly after the now-playing item and scramble the order. The FIFO anchor is now derived from the in-memory shadow (the authoritative play order), and reconciliation persists positions back to the DB so DB-backed queries no longer drift.
+
+### Added
+
+- **One-click playlist Reserve/Release.** The admin Playlists list now has a direct Reserve/Release action (and a Mutable/Immutable status) to toggle a saved playlist's immutability without digging into the editor. Immutable playlists' items stay hidden from public browse/search and reserved for scheduled play; releasing returns them to the catalog and pay-to-play.
+- **Scheduled-event pay-to-play lock with auto-expiry + manual unlock.** While an *immutable* scheduled playlist is playing, pay-to-play is locked so the curated event can't be interrupted. The lock now **auto-lifts once the last scheduled item begins playing** (so viewers can queue content for after the event). Admins get an **Unlock now** button (on the active-event banner and during a schedule's pre-fire window) that lifts the current lock while keeping the schedule armed for future firings — no more deleting the schedule to clear a lock.
+
+## [0.9.2] — 2026-06-09
+
 ### Fixed
 
 - Added missing `python-slugify>=8.0` core dependency (required by the `fetch` job).

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/PKG-INFO

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

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/catalog/db.py

@@ -271,6 +271,19 @@ MIGRATIONS = [
     """
     UPDATE catalog SET added_at = synced_at WHERE added_at IS NULL;
     """,
+    # v7: Per-schedule pre-fire lock override. Lets an admin lift a currently
+    # active pre-fire lock without deleting/unarming the (recurring) schedule.
+    # Reset to 0 whenever a recurring schedule re-arms its next occurrence.
+    """
+    ALTER TABLE playlist_schedules ADD COLUMN lock_disabled INTEGER NOT NULL DEFAULT 0;
+    """,
+    # v8: Track the firing's last scheduled item + an in-progress lock override
+    # so the scheduled-event lock can auto-lift once the last item begins
+    # playing, and admins can disable it mid-event.
+    """
+    ALTER TABLE active_schedule ADD COLUMN last_item_uid INTEGER;
+    ALTER TABLE active_schedule ADD COLUMN lock_disabled INTEGER NOT NULL DEFAULT 0;
+    """,
 ]
 
 
@@ -976,22 +989,46 @@ class Database:
         return await self._fetch_one("SELECT * FROM active_schedule WHERE id=1")
 
     async def set_active_schedule(self, *, schedule_id: int, playlist_id: int,
-                                  is_immutable: bool, started_at: str, estimated_end_at: str):
+                                  is_immutable: bool, started_at: str, estimated_end_at: str,
+                                  last_item_uid: int | None = None):
         await self._execute(
-            "INSERT OR REPLACE INTO active_schedule (id, schedule_id, playlist_id, is_immutable, started_at, estimated_end_at) "
-            "VALUES (1, ?, ?, ?, ?, ?)",
-            [schedule_id, playlist_id, int(is_immutable), started_at, estimated_end_at],
+            "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)",
+            [schedule_id, playlist_id, int(is_immutable), started_at, estimated_end_at, last_item_uid],
         )
 
     async def clear_active_schedule(self):
         await self._execute("DELETE FROM active_schedule WHERE id=1")
 
+    async def disable_active_lock(self):
+        """Lift the in-progress scheduled-event lock without ending the event.
+
+        Keeps the ``active_schedule`` row (so banners/state still show the event)
+        and leaves the underlying schedule armed for future occurrences.
+        """
+        await self._execute("UPDATE active_schedule SET lock_disabled=1 WHERE id=1")
+
+    async def is_event_lock_active(self) -> bool:
+        """True while an immutable scheduled event is locking pay-to-play.
+
+        Auto-lifts (via :meth:`disable_active_lock`, set when the last scheduled
+        item begins playing) and respects an admin's manual unlock.
+        """
+        row = await self.get_active_schedule()
+        if not row:
+            return False
+        if not row.get("is_immutable"):
+            return False
+        return not row.get("lock_disabled")
+
     # --- Pre-fire lock check ---
 
     async def is_pre_fire_lock_active(self) -> bool:
         row = await self._fetch_one("""
             SELECT 1 FROM playlist_schedules
             WHERE is_active = 1
+              AND lock_disabled = 0
               AND datetime(fire_at, '-' || pre_fire_lock_minutes || ' minutes') <= datetime('now')
               AND fire_at > datetime('now')
             LIMIT 1
@@ -1007,6 +1044,7 @@ class Database:
         return await self._fetch_one("""
             SELECT * FROM playlist_schedules
             WHERE is_active = 1
+              AND lock_disabled = 0
               AND datetime(fire_at, '-' || pre_fire_lock_minutes || ' minutes') <= datetime('now')
               AND fire_at > datetime('now')
             ORDER BY fire_at

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/playlists/fire.py

@@ -34,13 +34,16 @@ async def fire_schedule(*, schedule_id: int, api_gate, db, shadow, ws_manager):
         # Load scheduled playlist items
         items = await db.get_saved_playlist_items(playlist_id)
         total_duration = 0
+        last_item_uid = None
         for item in items:
             try:
-                await api_gate.playlist_add(
+                add_result = await api_gate.playlist_add(
                     media_type=item["media_type"],
                     media_id=item["media_id"],
                     position="end",
                 )
+                if isinstance(add_result, dict) and add_result.get("uid") is not None:
+                    last_item_uid = add_result["uid"]
                 total_duration += item.get("duration_sec", 0) or 0
             except Exception as e:
                 logger.warning(f"Schedule fire: failed to add {item['media_id']}: {e}")
@@ -53,6 +56,7 @@ async def fire_schedule(*, schedule_id: int, api_gate, db, shadow, ws_manager):
             is_immutable=playlist.get("is_immutable", False),
             started_at=now.isoformat(),
             estimated_end_at=(now + timedelta(seconds=total_duration)).isoformat(),
+            last_item_uid=last_item_uid,
         )
 
         # Mark schedule as fired

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/playlists/scheduler.py

@@ -71,7 +71,7 @@ class PlaylistScheduler:
                 if nxt:
                     nxt_utc = nxt.astimezone(UTC)
                     await self._db.update_schedule(
-                        sched["id"], fire_at=nxt_utc.isoformat(), fired_at=None
+                        sched["id"], fire_at=nxt_utc.isoformat(), fired_at=None, lock_disabled=0
                     )
                     self._add_job(sched["id"], nxt_utc)
                     logger.info(
@@ -115,7 +115,7 @@ class PlaylistScheduler:
             return
         nxt_utc = nxt.astimezone(UTC)
         await self._db.update_schedule(
-            schedule_id, fire_at=nxt_utc.isoformat(), fired_at=None
+            schedule_id, fire_at=nxt_utc.isoformat(), fired_at=None, lock_disabled=0
         )
         self._add_job(schedule_id, nxt_utc)
         logger.info(f"Recurring schedule {schedule_id} re-armed for {nxt_utc}")

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/queue/ordering.py

@@ -98,6 +98,24 @@ def _shadow_index_after_uid(shadow, target_uid: int | None) -> int:
     return len(shadow.items)
 
 
+def _last_pay_uid(shadow) -> int | None:
+    """UID of the last paid item in true play order, read from the in-memory shadow.
+
+    The in-memory shadow is rebuilt in CyTube playlist order on every poll, so
+    it is the authoritative source for FIFO positioning. (The persisted
+    ``queue_shadow.position`` column can lag between polls because reconciliation
+    re-indexes positions in memory only, which previously caused new paid items
+    to be anchored against a stale uid and land directly after the now-playing
+    item instead of at the tail of the pay queue.)
+    """
+    last = None
+    for it in shadow.items:
+        if it.get("is_pay"):
+            last = it.get("uid")
+    return last
+
+
+
 async def _move_after(api_gate, *, uid: int, target_uid: int | None) -> None:
     """Move uid to immediately after target_uid. No-op when target is None."""
     if target_uid is not None:
@@ -136,7 +154,7 @@ async def insert_pay_queue(
 
         # Target position: immediately after the LAST item in the persistent
         # pay-queue list, or after the currently-playing item when none exist.
-        last_pay_uid = await db.get_last_pay_uid()
+        last_pay_uid = _last_pay_uid(shadow)
         if last_pay_uid:
             target_uid = last_pay_uid
         else:
@@ -404,7 +422,7 @@ async def insert_admin_queue(
             # after_purchased: immediately after the LAST persistent pay item,
             # or after the currently-playing item when none exist.
             removed = 0
-            last_pay_uid = await db.get_last_pay_uid()
+            last_pay_uid = _last_pay_uid(shadow)
             if last_pay_uid:
                 target_uid = last_pay_uid
             else:

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/queue/shadow.py

@@ -86,6 +86,10 @@ class QueueShadow:
                         merged["media_id"] = media_id
                     if not merged.get("media_type") or merged.get("media_type") == "unknown":
                         merged["media_type"] = media_type
+                    # Persist the reconciled position so DB-backed queries
+                    # (e.g. last paid item) don't drift from true play order.
+                    if local_map[uid].get("position") != pos:
+                        await self._db.update_shadow_position(uid, pos)
                 else:
                     # New item from external source
                     merged = {
@@ -108,6 +112,65 @@ class QueueShadow:
 
             self._items = new_items
             await self._recalculate_estimated_starts()
+            await self._maybe_lift_event_lock()
+
+    async def _maybe_lift_event_lock(self):
+        """Auto-lift a scheduled-event lock once its last item begins playing.
+
+        When the currently-playing item is the last item that was loaded by the
+        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.
+        """
+        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:
+            return
+        idx = self._now_playing_index()
+        if idx is None:
+            return
+        cur_uid = self._items[idx].get("uid")
+        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")
+        except (TypeError, ValueError):
+            return
+
+    def _now_playing_index(self) -> int | None:
+        """Index of the currently-playing item within ``self._items``.
+
+        Prefers the playlist ``uid``; falls back to matching the now-playing
+        media id/type (CyTube's ``changeMedia`` payload carries no uid). Returns
+        None when there is no now-playing item or it cannot be located.
+        """
+        if not self._now_playing:
+            return None
+        np = self._now_playing
+        uid = np.get("uid")
+        if uid is not None:
+            try:
+                uid = int(uid)
+            except (TypeError, ValueError):
+                uid = None
+        if uid is not None:
+            for i, it in enumerate(self._items):
+                try:
+                    if int(it.get("uid")) == uid:
+                        return i
+                except (TypeError, ValueError):
+                    continue
+        np_id = np.get("id") or np.get("media_id")
+        np_type = np.get("type") or np.get("media_type")
+        if np_id is not None:
+            for i, it in enumerate(self._items):
+                if it.get("media_id") == np_id and (
+                    np_type is None or it.get("media_type") == np_type
+                ):
+                    return i
+        return None
 
     async def _recalculate_estimated_starts(self):
         """Recalculate estimated start times based on position and now-playing.
@@ -120,22 +183,46 @@ class QueueShadow:
         immune to server clock skew / timezone misconfiguration, which is the
         usual cause of ETAs appearing shifted by a whole UTC offset. The browser
         computes the wall-clock time from its own clock (Date.now() + offset).
+
+        ETAs are computed from the *remainder of the currently-playing item* and
+        proceed with the item AFTER it, wrapping around the end of the list back
+        to the items before it (CyTube loops the playlist). The current item may
+        sit at any position, not just index 0.
         """
         if not self._items:
             return
 
-        # Offset (seconds from now) until the head of the queue starts playing.
-        offset = 0.0
+        n = len(self._items)
+        now = datetime.now(UTC)
+
+        # Seconds left on the current item before the next one starts.
+        remaining = 0.0
         if self._now_playing:
             np_total = _to_seconds(self._now_playing.get("seconds", self._now_playing.get("duration")))
-            remaining = np_total - _to_seconds(self._now_playing.get("currentTime"))
-            offset = max(0.0, remaining)
+            remaining = max(0.0, np_total - _to_seconds(self._now_playing.get("currentTime")))
+
+        np_index = self._now_playing_index()
+
+        if np_index is None:
+            # No identifiable now-playing item: assume the head of the list is
+            # next, starting after the current item's remaining time.
+            offset = remaining
+            for item in self._items:
+                item["estimated_start_in_sec"] = round(offset)
+                item["estimated_start_at"] = (now + timedelta(seconds=offset)).isoformat()
+                offset += _to_seconds(item.get("duration_sec"))
+            return
 
-        now = datetime.now(UTC)
-        for item in self._items:
+        # The now-playing item is on screen now (offset 0).
+        np_item = self._items[np_index]
+        np_item["estimated_start_in_sec"] = 0
+        np_item["estimated_start_at"] = now.isoformat()
+
+        # Walk the rest in true play order, wrapping past the end of the list.
+        offset = remaining
+        for step in range(1, n):
+            item = self._items[(np_index + step) % n]
             item["estimated_start_in_sec"] = round(offset)
-            # Absolute timestamp retained for compatibility; relative offset is
-            # what the UI renders.
             item["estimated_start_at"] = (now + timedelta(seconds=offset)).isoformat()
             offset += _to_seconds(item.get("duration_sec"))
 

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/routes/admin_schedules.py

@@ -127,3 +127,26 @@ async def clear_active(request: Request, user: dict = Depends(require_admin)):
     db = request.app.state.db
     await db.clear_active_schedule()
     return {"success": True}
+
+
+@router.post("/unlock")
+async def unlock(request: Request, user: dict = Depends(require_admin)):
+    """Lift the currently-active pay-to-play lock without deleting the schedule.
+
+    Targets the in-progress scheduled-event lock first (keeps the event banner
+    and any recurring schedule armed); otherwise lifts an active pre-fire lock
+    for its current occurrence only (a recurring schedule re-locks on its next
+    firing).
+    """
+    db = request.app.state.db
+
+    if await db.is_event_lock_active():
+        await db.disable_active_lock()
+        return {"success": True, "lifted": "event"}
+
+    prefire = await db.get_active_pre_fire_lock()
+    if prefire:
+        await db.update_schedule(prefire["id"], lock_disabled=1)
+        return {"success": True, "lifted": "pre_fire"}
+
+    return {"success": True, "lifted": None}

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/routes/queue.py

@@ -26,6 +26,25 @@ async def _pre_fire_lock_detail(db) -> str:
         return f'Pay-to-play is closed ahead of "{label}". Try again after the event.'
 
 
+async def _queue_lock_detail(db) -> str:
+    """Pay-to-play lock message, covering both the pre-fire window and an
+    in-progress scheduled event."""
+    if await db.is_pre_fire_lock_active():
+        return await _pre_fire_lock_detail(db)
+    active = await db.get_active_schedule()
+    label = "a scheduled event"
+    if active and active.get("playlist_id"):
+        playlist = await db.get_saved_playlist(active["playlist_id"])
+        if playlist and playlist.get("name"):
+            label = playlist["name"]
+    return f'Pay-to-play is closed during "{label}". It reopens when the last scheduled item begins playing.'
+
+
+async def _queue_locked(db) -> bool:
+    """True when pay-to-play is closed by either lock type."""
+    return await db.is_pre_fire_lock_active() or await db.is_event_lock_active()
+
+
 @router.get("/state")
 async def get_queue_state(request: Request, user: dict = Depends(get_current_user)):
     """Get current queue state."""
@@ -48,9 +67,9 @@ async def add_to_queue(request: Request, user: dict = Depends(get_current_user))
     api_gate = request.app.state.api_gate
     shadow = request.app.state.shadow
 
-    # Check pre-fire lock
-    if await db.is_pre_fire_lock_active():
-        raise HTTPException(423, await _pre_fire_lock_detail(db))
+    # Check pay-to-play locks (pre-fire window or in-progress scheduled event)
+    if await _queue_locked(db):
+        raise HTTPException(423, await _queue_lock_detail(db))
 
     # Look up catalog item
     item = await db.get_item(friendly_token)
@@ -104,9 +123,9 @@ async def play_next(request: Request, user: dict = Depends(get_current_user)):
     api_gate = request.app.state.api_gate
     shadow = request.app.state.shadow
 
-    # Check pre-fire lock
-    if await db.is_pre_fire_lock_active():
-        raise HTTPException(423, await _pre_fire_lock_detail(db))
+    # Check pay-to-play locks (pre-fire window or in-progress scheduled event)
+    if await _queue_locked(db):
+        raise HTTPException(423, await _queue_lock_detail(db))
 
     # Look up catalog item
     item = await db.get_item(friendly_token)

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/templates/admin/playlists.html

@@ -87,9 +87,12 @@ async function loadPlaylists() {
             <tr>
                 <td><a href="#" onclick="openEditor(${p.id});return false;">${escapeHtml(p.name)}</a>
                     ${p.description ? `<div class="muted">${escapeHtml(p.description)}</div>` : ''}</td>
-                <td>${p.is_immutable ? '<span class="badge badge-warn">Immutable</span>' : '—'}</td>
+                <td>${p.is_immutable ? '<span class="badge badge-warn">Immutable</span>' : '<span class="muted">Mutable</span>'}</td>
                 <td>${escapeHtml(p.created_by || '')}</td>
                 <td class="row-actions">
+                    <button class="btn btn-sm" onclick="toggleImmutable(${p.id}, ${p.is_immutable ? 1 : 0}, '${escapeHtml(p.name)}')"
+                        title="${p.is_immutable ? 'Release items back to the public catalog' : 'Reserve items — hide from public catalog/search'}">
+                        ${p.is_immutable ? 'Release' : 'Reserve'}</button>
                     <button class="btn btn-sm" onclick="openEditor(${p.id})">Edit</button>
                     <button class="btn btn-sm btn-danger" onclick="deletePlaylist(${p.id}, '${escapeHtml(p.name)}')">Delete</button>
                 </td>
@@ -97,6 +100,20 @@ async function loadPlaylists() {
     </table>`;
 }
 
+async function toggleImmutable(id, currentlyImmutable, name) {
+    const makeImmutable = !currentlyImmutable;
+    const verb = makeImmutable ? 'Reserve' : 'Release';
+    if (!confirm(`${verb} "${name}"?\n\n${makeImmutable
+        ? 'Its items will be hidden from the public catalog and search and reserved for scheduled play.'
+        : 'Its items will return to the public catalog and become available for pay-to-play.'}`)) return;
+    const resp = await fetch(`/admin/playlists/${id}`, {
+        method: 'PUT', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({is_immutable: makeImmutable})
+    });
+    showToast(resp.ok ? `${verb}d` : `${verb} failed`, resp.ok ? 'success' : 'error');
+    loadPlaylists();
+}
+
 function showCreateModal() {
     showModal(`
         <h3>New Playlist</h3>

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/kryten_webqueue/templates/admin/schedules.html

@@ -42,11 +42,23 @@ async function loadActive() {
     if (!a || !a.schedule_id) { banner.classList.add('hidden'); return; }
     const name = playlistMap[a.playlist_id] || `Playlist #${a.playlist_id}`;
     banner.classList.remove('hidden');
+    const locked = a.is_immutable && !a.lock_disabled;
     banner.innerHTML = `
         <strong>Active schedule running:</strong> ${escapeHtml(name)}
         ${a.is_immutable ? '<span class="badge badge-warn">Immutable</span>' : ''}
+        ${locked ? '<span class="badge badge-warn">Pay-to-play locked</span>' : '<span class="badge">Unlocked</span>'}
         ${a.estimated_end_at ? `<div class="muted">Ends ~${formatLocalDateTime(a.estimated_end_at)}</div>` : ''}
-        <div style="margin-top:0.5rem;"><button class="btn btn-sm btn-danger" onclick="clearActive()">Clear Active</button></div>`;
+        <div style="margin-top:0.5rem;">
+            ${locked ? '<button class="btn btn-sm" onclick="unlockNow()">Unlock now</button> ' : ''}
+            <button class="btn btn-sm btn-danger" onclick="clearActive()">Clear Active</button>
+        </div>`;
+}
+
+async function unlockNow() {
+    if (!confirm('Lift the pay-to-play lock now? Users will be able to queue items again. The schedule stays armed for future firings.')) return;
+    const resp = await fetch('/admin/schedules/unlock', {method: 'POST'});
+    showToast(resp.ok ? 'Lock lifted' : 'Failed', resp.ok ? 'success' : 'error');
+    loadSchedules();
 }
 
 async function clearActive() {
@@ -69,11 +81,16 @@ async function loadSchedules() {
         <tr><th>Label</th><th>Playlist</th><th>Fires</th><th>Lock</th><th>Status</th><th></th></tr>
         ${rows.map(s => {
             const fired = s.fired_at ? 'fired' : (new Date(s.fire_at).getTime() < now ? 'past' : 'pending');
+            const fireMs = new Date(s.fire_at).getTime();
+            const lockMin = s.pre_fire_lock_minutes ?? 15;
+            const inPreFire = s.is_active && !isNaN(fireMs)
+                && now >= fireMs - lockMin * 60000 && now < fireMs;
+            const preFireLocked = inPreFire && !s.lock_disabled;
             return `<tr>
                 <td>${escapeHtml(s.label)}${s.is_recurring ? ' <span class="badge">↻</span>' : ''}</td>
                 <td>${escapeHtml(playlistMap[s.playlist_id] || ('#' + s.playlist_id))}</td>
                 <td>${formatLocalDateTime(s.fire_at)}</td>
-                <td>${s.pre_fire_lock_minutes ?? 15}m</td>
+                <td>${lockMin}m${preFireLocked ? ' <button class="btn btn-xs" onclick="unlockNow()" title="Lift the active pre-fire lock now">Unlock</button>' : (inPreFire && s.lock_disabled ? ' <span class="muted">(unlocked)</span>' : '')}</td>
                 <td><span class="job-status job-status-${fired === 'pending' ? 'running' : (fired === 'fired' ? 'completed' : 'cancelled')}">${s.is_active ? fired : 'disabled'}</span></td>
                 <td class="row-actions">
                     <button class="btn btn-sm" onclick="fireNow(${s.id}, '${escapeHtml(s.label)}')">Fire Now</button>

{kryten_webqueue-0.9.2 → kryten_webqueue-0.9.3}/pyproject.toml

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

kryten_webqueue-0.9.3/tests/test_phase4_live_fixes.py

@@ -0,0 +1,170 @@
+"""Live-testing bug fixes (v0.9.3).
+
+Covers:
+  #1 ETA computed from the remainder of the current item and wrapping around
+     the playlist when the now-playing item is not at index 0.
+  #2 Paid FIFO anchor derived from the in-memory shadow (true play order).
+  #4 Scheduled-event lock: blocks pay-to-play while an immutable event plays,
+     auto-lifts when the last scheduled item begins, admin manual unlock, and
+     the per-schedule pre-fire lock override.
+"""
+
+from datetime import datetime, timedelta, UTC
+
+import pytest
+
+from kryten_webqueue.catalog.db import Database
+from kryten_webqueue.queue.shadow import QueueShadow
+from kryten_webqueue.queue.ordering import _last_pay_uid
+
+
+@pytest.fixture
+async def db(tmp_path):
+    database = Database(str(tmp_path / "test.db"))
+    await database.connect()
+    await database.run_migrations()
+    yield database
+    await database.close()
+
+
+def _polled(uid: int, *, seconds: int = 100):
+    """A CyTube-style polled playlist entry."""
+    return {
+        "uid": uid,
+        "queueby": None,
+        "media": {"id": f"m{uid}", "type": "cm", "title": f"Item {uid}", "seconds": seconds},
+    }
+
+
+# --- #1 ETA wrap-around ---
+
+async def test_eta_wraps_from_current_item(db):
+    shadow = QueueShadow(db)
+    items = [_polled(1), _polled(2), _polled(3), _polled(4)]  # 100s each
+    # The current item is uid=2 (index 1), 40s elapsed -> 60s remaining.
+    now_playing = {"uid": 2, "seconds": 100, "currentTime": 40}
+    await shadow.apply_poll_result(items, now_playing)
+
+    eta = {it["uid"]: it["estimated_start_in_sec"] for it in shadow.items}
+    # Current item plays now.
+    assert eta[2] == 0
+    # Next is uid=3 after the 60s remainder, then uid=4, then wrap to uid=1.
+    assert eta[3] == 60
+    assert eta[4] == 160
+    assert eta[1] == 260
+
+
+async def test_eta_without_now_playing_starts_at_head(db):
+    shadow = QueueShadow(db)
+    items = [_polled(1), _polled(2)]
+    await shadow.apply_poll_result(items, None)
+    eta = {it["uid"]: it["estimated_start_in_sec"] for it in shadow.items}
+    assert eta[1] == 0
+    assert eta[2] == 100
+
+
+# --- #2 paid FIFO anchor from in-memory shadow ---
+
+async def test_last_pay_uid_from_shadow_order(db):
+    shadow = QueueShadow(db)
+    # Build a shadow directly: now-playing free item, then two paid items.
+    shadow._items = [
+        {"uid": 10, "is_pay": False},
+        {"uid": 11, "is_pay": True},
+        {"uid": 12, "is_pay": True},
+        {"uid": 13, "is_pay": False},
+    ]
+    assert _last_pay_uid(shadow) == 12
+
+    # No paid items -> None (caller then anchors after now-playing).
+    shadow._items = [{"uid": 1, "is_pay": False}]
+    assert _last_pay_uid(shadow) is None
+
+
+async def test_poll_persists_positions(db):
+    """Reconciliation must persist positions so DB-backed queries don't drift."""
+    shadow = QueueShadow(db)
+    await shadow.apply_poll_result([_polled(1), _polled(2), _polled(3)], None)
+    # Reorder externally: uid 3 moves to the front.
+    await shadow.apply_poll_result([_polled(3), _polled(1), _polled(2)], None)
+    rows = await db.get_shadow_items()
+    by_uid = {r["uid"]: r["position"] for r in rows}
+    assert by_uid == {3: 0, 1: 1, 2: 2}
+
+
+# --- #4 scheduled-event lock ---
+
+async def _make_event(db, *, is_immutable=True, last_item_uid=99):
+    pid = await db.create_saved_playlist(
+        name="Event", description=None, is_immutable=is_immutable, created_by="admin"
+    )
+    sid = await db.create_schedule(
+        playlist_id=pid,
+        label="Event",
+        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=is_immutable,
+        started_at=now.isoformat(),
+        estimated_end_at=(now + timedelta(hours=1)).isoformat(),
+        last_item_uid=last_item_uid,
+    )
+    return sid, pid
+
+
+async def test_event_lock_active_and_manual_unlock(db):
+    await _make_event(db, is_immutable=True)
+    assert await db.is_event_lock_active() is True
+
+    await db.disable_active_lock()
+    assert await db.is_event_lock_active() is False
+    # The active row is kept (event still "running"), just unlocked.
+    assert (await db.get_active_schedule()) is not None
+
+
+async def test_mutable_event_does_not_lock(db):
+    await _make_event(db, is_immutable=False)
+    assert await db.is_event_lock_active() is False
+
+
+async def test_event_lock_auto_lifts_when_last_item_plays(db):
+    _, _ = await _make_event(db, last_item_uid=3)
+    assert await db.is_event_lock_active() is True
+
+    shadow = QueueShadow(db)
+    items = [_polled(1), _polled(2), _polled(3)]
+    # The last scheduled item (uid=3) begins playing.
+    await shadow.apply_poll_result(items, {"uid": 3, "seconds": 100, "currentTime": 0})
+    assert await db.is_event_lock_active() is False
+
+
+async def test_event_lock_stays_until_last_item(db):
+    await _make_event(db, last_item_uid=3)
+    shadow = QueueShadow(db)
+    items = [_polled(1), _polled(2), _polled(3)]
+    # An earlier item is playing -> still locked.
+    await shadow.apply_poll_result(items, {"uid": 1, "seconds": 100, "currentTime": 0})
+    assert await db.is_event_lock_active() is True
+
+
+# --- #4 pre-fire lock override ---
+
+async def test_pre_fire_lock_can_be_disabled(db):
+    pid = await db.create_saved_playlist(
+        name="P", description=None, is_immutable=True, created_by="admin"
+    )
+    fire_at = (datetime.now(UTC) + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%S")
+    sid = await db.create_schedule(
+        playlist_id=pid, label="Soon", fire_at=fire_at,
+        pre_fire_lock_minutes=15, is_active=1, created_by="admin",
+    )
+    # Within the 15-min pre-fire window (fires in 5 min).
+    assert await db.is_pre_fire_lock_active() is True
+
+    await db.update_schedule(sid, lock_disabled=1)
+    assert await db.is_pre_fire_lock_active() is False