kryten-webqueue 0.32.0__tar.gz → 0.32.2__tar.gz

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 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).
 
+## [0.32.2] — 2026-07-09
+
+### Fixed
+
+- **Promo clips are exempt from recently-played hiding.** Playing a promo-pool clip no longer records any hide state — promos are already excluded from the public catalog and must not be treated like normal mutable/immutable playlist items. `record_play_completion` now skips promo-pool members entirely. A one-time migration (v14) purges any promo hide state recorded before this fix; the same cleanup is also available on-demand via `purge_promo_hide_state()`.
+
+## [0.32.1] — 2026-07-09
+
+### Added
+
+- **Admin controls to test recently-played hiding in situ** without waiting for real playback:
+  - `POST /admin/catalog/{token}/mark-played` — simulates a genuine completion via the same `record_play_completion` the poll loop uses, so it also exercises the mutable-playlist pass logic (marking episodes, resetting on the last item).
+  - `POST /admin/catalog/{token}/clear-played` — removes an item's completion and playlist-pass rows so it reappears for regular users immediately.
+  - `GET /admin/catalog/recently-played/debug` — read-only snapshot of exactly what regular users are not seeing and why (time-window vs mutable-playlist pass).
+  - The admin catalog browser gains **Mark played** and **Clear played** buttons per item.
+
 ## [0.32.0] — 2026-07-09
 
 ### Added
@@ -17,6 +33,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Promos are unaffected — promo/immutable-playlist items are already excluded from the public catalog.
 
 [0.32.0]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.32.0
+[0.32.1]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.32.1
+[0.32.2]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.32.2
 
 ## [0.31.0] — 2026-07-04
 

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/PKG-INFO

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

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/kryten_webqueue/catalog/db/_catalog.py

@@ -360,7 +360,19 @@ class _CatalogMixin:
         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.
         """
+        promo = await self._fetch_one(
+            "SELECT 1 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.promo_type IS NOT NULL LIMIT 1",
+            [friendly_token, media_type],
+        )
+        if promo:
+            return
         rows = await self._fetch_all(
             """
             SELECT spi.playlist_id AS playlist_id, spi.position AS position,
@@ -409,6 +421,82 @@ class _CatalogMixin:
         )
         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).
+
+        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.
+        """
+        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}
+
+    async def purge_promo_hide_state(self) -> dict:
+        """Remove any recently-played hide state recorded for promo-pool clips.
+
+        Promos must never be subject to recently-played hiding. New completions
+        are already skipped in ``record_play_completion``; this purges rows
+        written before that exemption existed (also run once by migration v14).
+        Returns the row counts removed.
+        """
+        promo_subquery = (
+            "SELECT spi.media_id FROM saved_playlist_items spi "
+            "JOIN saved_playlists sp ON sp.id = spi.playlist_id "
+            "WHERE sp.promo_type IS NOT NULL AND spi.media_type = 'cm'"
+        )
+        pc = await self._fetch_one(
+            f"SELECT COUNT(*) AS c FROM play_completions WHERE media_id IN ({promo_subquery})"
+        )
+        pip = await self._fetch_one(
+            f"SELECT COUNT(*) AS c FROM playlist_item_played WHERE media_id IN ({promo_subquery})"
+        )
+        await self._execute(f"DELETE FROM play_completions WHERE media_id IN ({promo_subquery})")
+        await self._execute(f"DELETE FROM playlist_item_played WHERE media_id IN ({promo_subquery})")
+        return {"completions": pc["c"] if pc else 0, "playlist_pass": pip["c"] if pip 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.
+        """
+        by_completion = await self._fetch_all(
+            "SELECT pc.media_id, c.title, MAX(pc.completed_at) AS last_completed "
+            "FROM play_completions pc "
+            "LEFT JOIN catalog c ON c.friendly_token = pc.media_id "
+            "WHERE pc.media_type = 'cm' AND pc.completed_at >= datetime('now', ?) "
+            "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(self, tokens: list[str], manifest_urls: list[str]) -> dict[str, dict]:
         """Return a lookup of catalog metadata keyed by BOTH friendly_token and
         manifest_url, for enriching queue-shadow items that may only carry one.

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/kryten_webqueue/catalog/db/_connection.py

@@ -291,6 +291,24 @@ 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
+    # 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.
+    """
+    DELETE FROM play_completions
+    WHERE media_id IN (
+        SELECT spi.media_id FROM saved_playlist_items spi
+        JOIN saved_playlists sp ON sp.id = spi.playlist_id
+        WHERE sp.promo_type IS NOT NULL AND spi.media_type = 'cm'
+    );
+    DELETE FROM playlist_item_played
+    WHERE media_id IN (
+        SELECT spi.media_id FROM saved_playlist_items spi
+        JOIN saved_playlists sp ON sp.id = spi.playlist_id
+        WHERE sp.promo_type IS NOT NULL AND spi.media_type = 'cm'
+    );
+    """,
 ]
 
 

kryten_webqueue-0.32.2/kryten_webqueue/routes/admin_catalog.py

@@ -0,0 +1,92 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+
+from ..auth.session import require_admin
+from ..catalog.db import HIDDEN_ITEM_TAG
+from ..catalog.mediacms import MediaCMSClient
+
+router = APIRouter(prefix="/admin/catalog", tags=["admin"])
+
+
+def _mediacms_client(request: Request) -> MediaCMSClient:
+    config = request.app.state.config
+    return MediaCMSClient(mediacms_url=config.mediacms_url, token=config.mediacms_token)
+
+
+@router.post("/{friendly_token}/hide")
+async def hide_item(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
+    """Tag an item ``kryten-hidden`` in MediaCMS and hide it locally (B6).
+
+    The local catalog is updated immediately so the admin sees the item
+    disappear; the next sync re-reads the tag from MediaCMS (the source of
+    truth) and the hide persists.
+    """
+    db = request.app.state.db
+    item = await db.get_item_admin(friendly_token)
+    if not item:
+        raise HTTPException(404, "Catalog item not found")
+
+    # Local mirror first so the UI hides immediately regardless of the remote
+    # write outcome (which can be retried/confirmed by sync).
+    await db.add_catalog_tag(friendly_token, HIDDEN_ITEM_TAG)
+    remote_ok = await _mediacms_client(request).set_tag(friendly_token, HIDDEN_ITEM_TAG, present=True)
+    return {"success": True, "remote_ok": remote_ok}
+
+
+@router.post("/{friendly_token}/unhide")
+async def unhide_item(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
+    """Remove the ``kryten-hidden`` tag in MediaCMS and locally (B6)."""
+    db = request.app.state.db
+    item = await db.get_item_admin(friendly_token)
+    if not item:
+        raise HTTPException(404, "Catalog item not found")
+
+    await db.remove_catalog_tag(friendly_token, HIDDEN_ITEM_TAG)
+    remote_ok = await _mediacms_client(request).set_tag(friendly_token, HIDDEN_ITEM_TAG, present=False)
+    return {"success": True, "remote_ok": remote_ok}
+
+
+# --- Recently-played test helpers (admin-only) -----------------------------
+#
+# These let an admin exercise the v0.32 "hide recently-played" rules in situ
+# without waiting for real playback: simulate a completion, clear an item's
+# hide state, or inspect exactly what a regular user would not see.
+
+@router.post("/{friendly_token}/mark-played")
+async def mark_played(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
+    """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
+    as it would after real playback.
+    """
+    db = request.app.state.db
+    item = await db.get_item_admin(friendly_token)
+    if not item:
+        raise HTTPException(404, "Catalog item not found")
+    await db.record_play_completion(
+        friendly_token=friendly_token,
+        duration_sec=item.get("duration_sec"),
+    )
+    return {"success": True}
+
+
+@router.post("/{friendly_token}/clear-played")
+async def clear_played(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
+    """Clear an item's recently-played hide state so it reappears immediately."""
+    db = request.app.state.db
+    item = await db.get_item_admin(friendly_token)
+    if not item:
+        raise HTTPException(404, "Catalog item not found")
+    removed = await db.clear_play_state(friendly_token)
+    return {"success": True, "removed": removed}
+
+
+@router.get("/recently-played/debug")
+async def recently_played_debug(request: Request, user: dict = Depends(require_admin)):
+    """List what the recently-played rules currently hide from regular users."""
+    db = request.app.state.db
+    days = request.app.state.config.catalog_recently_played_hide_days
+    return await db.get_recently_played_debug(days)
+

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/kryten_webqueue/templates/catalog/browse.html

@@ -94,6 +94,8 @@
             <button class="btn btn-sm btn-admin" onclick="queueAsAdmin('{{ item.friendly_token }}')">Queue as Admin</button>
             <button class="btn btn-sm" onclick="addToPlaylist('{{ item.friendly_token }}')">Add to playlist</button>
             <button class="btn btn-sm" onclick="addToRecentPlaylist('{{ item.friendly_token }}')">+ Recent</button>
+            <button class="btn btn-sm" onclick="markPlayed('{{ item.friendly_token }}')" title="Simulate a play-completion so this item hides from regular users (testing)">Mark played</button>
+            <button class="btn btn-sm" onclick="clearPlayed('{{ item.friendly_token }}')" title="Clear recently-played hide state so this item reappears for regular users">Clear played</button>
             <button class="btn btn-sm btn-danger" onclick="hideItem('{{ item.friendly_token }}')">Hide</button>
             {% endif %}
         </div>
@@ -378,6 +380,40 @@ async function hideItem(token) {
         showToast(`Network error: ${e.message}`, 'error');
     }
 }
+
+async function markPlayed(token) {
+    try {
+        const resp = await fetch(`/admin/catalog/${encodeURIComponent(token)}/mark-played`, {
+            method: 'POST', credentials: 'same-origin'
+        });
+        if (resp.ok) {
+            showToast('Marked played — now hidden from regular users');
+        } else {
+            const data = await resp.json().catch(() => ({}));
+            showToast(data.detail || `Failed (${resp.status})`, 'error');
+        }
+    } catch (e) {
+        showToast(`Network error: ${e.message}`, 'error');
+    }
+}
+
+async function clearPlayed(token) {
+    try {
+        const resp = await fetch(`/admin/catalog/${encodeURIComponent(token)}/clear-played`, {
+            method: 'POST', credentials: 'same-origin'
+        });
+        if (resp.ok) {
+            const data = await resp.json().catch(() => ({}));
+            const r = data.removed || {};
+            showToast(`Cleared play state (${r.completions || 0} completion, ${r.playlist_pass || 0} pass)`);
+        } else {
+            const data = await resp.json().catch(() => ({}));
+            showToast(data.detail || `Failed (${resp.status})`, 'error');
+        }
+    } catch (e) {
+        showToast(`Network error: ${e.message}`, 'error');
+    }
+}
 // queueItem / playNext / queueAsAdmin / showToast / escapeHtml are provided by /static/js/main.js
 </script>
 {% endblock %}

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/pyproject.toml

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

{kryten_webqueue-0.32.0 → kryten_webqueue-0.32.2}/tests/test_recently_played_hide.py

@@ -309,3 +309,92 @@ async def test_import_full_loads_entire_list(db):
     assert result["skipped"] == 0
 
 
+# --- Admin test helpers (mark-played / clear / debug) ---------------------
+
+async def test_clear_play_state_unhides_time_window_item(db):
+    await _add_catalog(db, "movie", "Movie", duration_sec=7200)
+    await db.record_play_completion(friendly_token="movie", duration_sec=7200)
+    assert await _browse_tokens(db, recently_played_days=21) == set()
+
+    removed = await db.clear_play_state("movie")
+    assert removed == {"completions": 1, "playlist_pass": 0}
+    assert await _browse_tokens(db, recently_played_days=21) == {"movie"}
+
+
+async def test_clear_play_state_unhides_playlist_episode(db):
+    tokens = ["ep1", "ep2", "ep3"]
+    for t in tokens:
+        await _add_catalog(db, t, f"Episode {t}", duration_sec=1500)
+    await _make_mutable_playlist(db, tokens, duration_sec=1500)
+    await db.record_play_completion(friendly_token="ep1", duration_sec=1500)
+    assert "ep1" not in await _browse_tokens(db, recently_played_days=21)
+
+    removed = await db.clear_play_state("ep1")
+    assert removed["playlist_pass"] == 1
+    assert "ep1" in await _browse_tokens(db, recently_played_days=21)
+
+
+async def test_recently_played_debug_reports_both_signals(db):
+    await _add_catalog(db, "movie", "Movie", duration_sec=7200)
+    await _add_catalog(db, "ep1", "Episode 1", duration_sec=1500)
+    await _add_catalog(db, "ep2", "Episode 2", duration_sec=1500)
+    await _make_mutable_playlist(db, ["ep1", "ep2"], duration_sec=1500)
+
+    await db.record_play_completion(friendly_token="movie", duration_sec=7200)  # time window
+    await db.record_play_completion(friendly_token="ep1", duration_sec=1500)    # playlist pass
+
+    debug = await db.get_recently_played_debug(21)
+    assert debug["window_days"] == 21
+    assert {r["media_id"] for r in debug["by_completion"]} == {"movie"}
+    assert {r["media_id"] for r in debug["by_playlist_pass"]} == {"ep1"}
+
+
+async def test_promo_clips_are_exempt_from_hiding(db):
+    # A clip in a promo pool (promo_type set) must never be recorded as played
+    # nor appear in the recently-played debug list.
+    await _add_catalog(db, "promo1", "Bumper", duration_sec=30)
+    pid = await db.create_saved_playlist(
+        name="Bumpers", description=None, is_immutable=False,
+        created_by="admin", promo_type="general",
+    )
+    await db.replace_playlist_items(pid, [
+        {"media_type": "cm", "media_id": "promo1", "title": "Bumper", "duration_sec": 30},
+    ])
+
+    await db.record_play_completion(friendly_token="promo1", duration_sec=30)
+
+    rows = await db._fetch_all("SELECT media_id FROM play_completions")
+    assert rows == []
+    pip = await db._fetch_all("SELECT media_id FROM playlist_item_played")
+    assert pip == []
+    debug = await db.get_recently_played_debug(21)
+    assert debug["by_completion"] == []
+    assert debug["by_playlist_pass"] == []
+
+
+async def test_purge_promo_hide_state_removes_stale_rows(db):
+    # Rows recorded before the promo exemption (e.g. in production) are cleaned up
+    # at the data layer by purge_promo_hide_state (also run by migration v14).
+    await _add_catalog(db, "promo1", "Bumper", duration_sec=30)
+    pid = await db.create_saved_playlist(
+        name="Bumpers", description=None, is_immutable=False,
+        created_by="admin", promo_type="general",
+    )
+    await db.replace_playlist_items(pid, [
+        {"media_type": "cm", "media_id": "promo1", "title": "Bumper", "duration_sec": 30},
+    ])
+    # Simulate a stale row written before the exemption existed.
+    await db._execute("INSERT INTO play_completions (media_type, media_id) VALUES ('cm', 'promo1')")
+    # Before the purge it shows in the (unfiltered) debug view.
+    assert {r["media_id"] for r in (await db.get_recently_played_debug(21))["by_completion"]} == {"promo1"}
+
+    removed = await db.purge_promo_hide_state()
+    assert removed["completions"] == 1
+
+    assert await db._fetch_all("SELECT media_id FROM play_completions") == []
+    assert (await db.get_recently_played_debug(21))["by_completion"] == []
+
+
+
+
+

kryten_webqueue-0.32.0/kryten_webqueue/routes/admin_catalog.py

@@ -1,45 +0,0 @@
-from fastapi import APIRouter, Request, Depends, HTTPException
-
-from ..auth.session import require_admin
-from ..catalog.db import HIDDEN_ITEM_TAG
-from ..catalog.mediacms import MediaCMSClient
-
-router = APIRouter(prefix="/admin/catalog", tags=["admin"])
-
-
-def _mediacms_client(request: Request) -> MediaCMSClient:
-    config = request.app.state.config
-    return MediaCMSClient(mediacms_url=config.mediacms_url, token=config.mediacms_token)
-
-
-@router.post("/{friendly_token}/hide")
-async def hide_item(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
-    """Tag an item ``kryten-hidden`` in MediaCMS and hide it locally (B6).
-
-    The local catalog is updated immediately so the admin sees the item
-    disappear; the next sync re-reads the tag from MediaCMS (the source of
-    truth) and the hide persists.
-    """
-    db = request.app.state.db
-    item = await db.get_item_admin(friendly_token)
-    if not item:
-        raise HTTPException(404, "Catalog item not found")
-
-    # Local mirror first so the UI hides immediately regardless of the remote
-    # write outcome (which can be retried/confirmed by sync).
-    await db.add_catalog_tag(friendly_token, HIDDEN_ITEM_TAG)
-    remote_ok = await _mediacms_client(request).set_tag(friendly_token, HIDDEN_ITEM_TAG, present=True)
-    return {"success": True, "remote_ok": remote_ok}
-
-
-@router.post("/{friendly_token}/unhide")
-async def unhide_item(request: Request, friendly_token: str, user: dict = Depends(require_admin)):
-    """Remove the ``kryten-hidden`` tag in MediaCMS and locally (B6)."""
-    db = request.app.state.db
-    item = await db.get_item_admin(friendly_token)
-    if not item:
-        raise HTTPException(404, "Catalog item not found")
-
-    await db.remove_catalog_tag(friendly_token, HIDDEN_ITEM_TAG)
-    remote_ok = await _mediacms_client(request).set_tag(friendly_token, HIDDEN_ITEM_TAG, present=False)
-    return {"success": True, "remote_ok": remote_ok}