kryten-webqueue 0.9.5__tar.gz → 0.9.7__tar.gz

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/CHANGELOG.md

@@ -6,6 +6,29 @@ 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.7] — 2026-06-11
+
+### Changed
+
+- **Paid-queue chat announcement reworded.** A purchased item now announces as `"<title> added to the queue with Zcoin by <user> and is now <position>."` where `<position>` is `next` for the item immediately after the currently-playing one, or an English ordinal counting the now-playing item as first (e.g. `third`, `forty-second`, `one hundred seventh`). Position is computed relative to the currently-playing item and wraps around the playlist.
+- **Admin queueing is no longer announced** in the channel chat (only paid placements are announced).
+- Renamed the admin Schedules heading from “Scheduled Fires” to “Scheduled Events”.
+
+## [0.9.6] — 2026-06-11
+
+### Added
+
+- **Richer Bulk Text Import on the admin Playlists editor.** The text import now accepts, one entry per line:
+  - **dropsugar.co / dropsugar.com links** (watch `?m=TOKEN` or manifest `/api/v1/media/cytube/TOKEN.json`) — resolved against the catalog for title/duration, falling back to a constructed manifest URL when the token isn't catalogued yet.
+  - **YouTube / youtu.be links** — playlist (`list=`), start-time (`t`/`start`) and all other arguments are stripped, leaving a clean `yt:VIDEOID` item.
+  - Legacy `cm:token`, `yt:id`, and bare catalog tokens (unchanged).
+  - Trailing free text after a URL (e.g. `URL - My Title`) is used as a title hint.
+- **Upload a local text file** into the importer via a "Choose text file…" button (contents are loaded into the textarea for review before parsing).
+
+### Changed
+
+- The text import parser is now **tolerant**: blank lines, whole-line `#` comments, and inline trailing `#` comments are ignored, and links to unknown sites are skipped (reported as `unsupported_site`) instead of failing the import.
+
 ## [0.9.5] — 2026-06-11
 
 ### Changed

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/PKG-INFO

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

kryten_webqueue-0.9.7/kryten_webqueue/playlists/importer.py

@@ -0,0 +1,209 @@
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+# --- URL parsing helpers (module-level, pure) ---
+
+_YT_ID = r"[A-Za-z0-9_-]{11}"
+
+
+def extract_youtube_id(url: str) -> str | None:
+    """Return the 11-char YouTube video id from any YouTube/youtu.be URL.
+
+    Strips playlists (``list=``), start times (``t=``/``start=``) and every
+    other query/path argument. Returns None when no video id is present (e.g. a
+    bare ``/playlist?list=...`` link, which we do not expand)."""
+    # youtu.be/<id>
+    m = re.search(rf"youtu\.be/({_YT_ID})", url)
+    if m:
+        return m.group(1)
+    # youtube.com/watch?v=<id>
+    m = re.search(rf"[?&]v=({_YT_ID})", url)
+    if m:
+        return m.group(1)
+    # youtube.com/shorts/<id>, /embed/<id>, /v/<id>, /live/<id>
+    m = re.search(rf"/(?:shorts|embed|v|live)/({_YT_ID})", url)
+    if m:
+        return m.group(1)
+    return None
+
+
+def extract_dropsugar_token(url: str) -> str | None:
+    """Return the MediaCMS friendly_token from a dropsugar manifest/view URL."""
+    m = re.search(r"/media/cytube/([^./?&]+)\.json", url)
+    if m:
+        return m.group(1)
+    m = re.search(r"[?&]m=([^&]+)", url)
+    if m:
+        return m.group(1)
+    return None
+
+
+def _is_youtube(host: str) -> bool:
+    host = host.lower()
+    return "youtube.com" in host or "youtu.be" in host
+
+
+def _is_dropsugar(host: str) -> bool:
+    return "dropsugar." in host.lower()
+
+
+def _manifest_url_for_token(token: str, mediacms_url: str | None) -> str | None:
+    if not mediacms_url:
+        return None
+    return f"{mediacms_url.rstrip('/')}/api/v1/media/cytube/{token}.json?format=json"
+
+
+class PlaylistImporter:
+    """Imports items from a saved playlist into the live CyTube queue."""
+
+    def __init__(self, *, api_gate, db, shadow):
+        self._api_gate = api_gate
+        self._db = db
+        self._shadow = shadow
+
+    async def import_playlist(self, playlist_id: int) -> dict:
+        """Import all 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"}
+
+        added = 0
+        errors = 0
+        for item in items:
+            try:
+                result = await self._api_gate.playlist_add(
+                    media_type=item["media_type"],
+                    media_id=item["media_id"],
+                    position="end",
+                )
+                if result.get("success"):
+                    added += 1
+                else:
+                    errors += 1
+            except Exception as e:
+                logger.warning(f"Failed to add {item['media_id']}: {e}")
+                errors += 1
+
+        return {"success": True, "added": added, "errors": errors}
+
+
+async def import_playlist_text(db, text: str, *, mediacms_url: str | None = None) -> dict:
+    """Parse the plain-text playlist import format into resolved items.
+
+    Tolerant by design — never raises; unrecognised lines are reported in
+    ``errors`` so the import can proceed with whatever resolved.
+
+    Supported per line (one entry per line):
+      - Blank lines are skipped.
+      - ``#`` starts a comment: a whole-line comment, or an inline trailing
+        comment (everything from the first ``#`` is ignored).
+      - **dropsugar.co / dropsugar.com URLs** — watch (``/view?m=TOKEN``) or
+        manifest (``/api/v1/media/cytube/TOKEN.json``) links. Resolved against
+        the catalog (for title/duration); falls back to a constructed manifest
+        URL when the token isn't catalogued yet.
+      - **YouTube / youtu.be URLs** — playlist, start-time (``t``) and all other
+        arguments are stripped, leaving a clean ``yt:VIDEOID`` item.
+      - Other ``http(s)`` URLs (unknown sites) are skipped (reported as
+        ``unsupported_site``).
+      - Legacy tokens: ``cm:token``, ``yt:id``, or a bare catalog token.
+      - Trailing free text after a URL (e.g. ``URL - Some Title``) is used as a
+        title hint for items not found in the catalog.
+
+    Returns: ``{"items": [...], "errors": [...]}``.
+    """
+    items = []
+    errors = []
+    url_re = re.compile(r"https?://\S+")
+
+    for line_num, raw in enumerate(text.splitlines(), 1):
+        # Strip inline comments: everything from the first '#'.
+        line = raw.split("#", 1)[0].strip()
+        if not line:
+            continue
+
+        url_match = url_re.search(line)
+        if url_match:
+            url = url_match.group(0).rstrip(".,;")
+            # Free text after the URL is a title hint (e.g. " - My Title").
+            trailing = line[url_match.end():].strip().lstrip("-–").strip()
+            title_hint = trailing or None
+            host = re.sub(r"^https?://", "", url).split("/", 1)[0]
+
+            if _is_youtube(host):
+                vid = extract_youtube_id(url)
+                if vid:
+                    items.append({
+                        "media_type": "yt",
+                        "media_id": vid,
+                        "title": title_hint,
+                        "duration_sec": None,
+                    })
+                else:
+                    errors.append({"line": line_num, "token": url, "reason": "youtube_no_video_id"})
+                continue
+
+            if _is_dropsugar(host):
+                token = extract_dropsugar_token(url)
+                if not token:
+                    errors.append({"line": line_num, "token": url, "reason": "no_token_in_url"})
+                    continue
+                catalog_item = await db.get_item_admin(token)
+                if catalog_item:
+                    items.append({
+                        "media_type": "cm",
+                        "media_id": catalog_item["manifest_url"],
+                        "title": catalog_item.get("title") or title_hint,
+                        "duration_sec": catalog_item.get("duration_sec"),
+                    })
+                else:
+                    manifest = _manifest_url_for_token(token, mediacms_url)
+                    if manifest:
+                        items.append({
+                            "media_type": "cm",
+                            "media_id": manifest,
+                            "title": title_hint,
+                            "duration_sec": None,
+                        })
+                    else:
+                        errors.append({"line": line_num, "token": token, "reason": "not_in_catalog"})
+                continue
+
+            # Any other site — skip tolerantly.
+            errors.append({"line": line_num, "token": url, "reason": "unsupported_site"})
+            continue
+
+        # --- legacy token forms (no URL on the line) ---
+        if line.startswith("cm:"):
+            media_id = line[3:].strip()
+            catalog_item = await db.get_item_admin(media_id)
+            items.append({
+                "media_type": "cm",
+                "media_id": catalog_item["manifest_url"] if catalog_item else media_id,
+                "title": catalog_item["title"] if catalog_item else None,
+                "duration_sec": catalog_item["duration_sec"] if catalog_item else None,
+            })
+        elif line.startswith("yt:"):
+            items.append({
+                "media_type": "yt",
+                "media_id": line[3:].strip(),
+                "title": None,
+                "duration_sec": None,
+            })
+        else:
+            # Bare token — resolve from catalog.
+            catalog_item = await db.get_item_admin(line)
+            if catalog_item:
+                items.append({
+                    "media_type": "cm",
+                    "media_id": catalog_item["manifest_url"],
+                    "title": catalog_item["title"],
+                    "duration_sec": catalog_item["duration_sec"],
+                })
+            else:
+                errors.append({"line": line_num, "token": line, "reason": "not_in_catalog"})
+
+    return {"items": items, "errors": errors}
+

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/kryten_webqueue/queue/ordering.py

@@ -26,7 +26,7 @@ def _add_failure_reason(add_result: dict | None, exc: httpx.HTTPStatusError | No
 
 
 def _announcement_position(shadow, uid: int) -> int | None:
-    """Position of the item for chat announcement.
+    """Position of the item for chat announcement (deprecated; kept for tests).
 
     Counting starts at the currently-playing item (position 0), so the next
     item to play is position 1. The shadow mirrors the full CyTube playlist
@@ -39,13 +39,80 @@ def _announcement_position(shadow, uid: int) -> int | None:
     return None
 
 
-async def _announce_queued(api_gate, shadow, *, uid: int, title: str, username: str) -> None:
-    """Announce a successful queue placement to the channel chat."""
-    pos = _announcement_position(shadow, uid)
-    if pos is None:
+_ONES_ORDINAL = {
+    "one": "first", "two": "second", "three": "third", "five": "fifth",
+    "eight": "eighth", "nine": "ninth", "twelve": "twelfth",
+}
+_ONES = ["", "one", "two", "three", "four", "five", "six", "seven", "eight",
+         "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
+         "sixteen", "seventeen", "eighteen", "nineteen"]
+_TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
+         "eighty", "ninety"]
+
+
+def _cardinal_words(n: int) -> str:
+    """English cardinal words for 1..999 (queue positions never exceed this)."""
+    if n < 20:
+        return _ONES[n]
+    if n < 100:
+        tens, ones = divmod(n, 10)
+        return _TENS[tens] + (f"-{_ONES[ones]}" if ones else "")
+    hundreds, rem = divmod(n, 100)
+    head = f"{_ONES[hundreds]} hundred"
+    return f"{head} {_cardinal_words(rem)}" if rem else head
+
+
+def _to_ordinal_word(word: str) -> str:
+    """Convert a single cardinal word to its ordinal form."""
+    if word in _ONES_ORDINAL:
+        return _ONES_ORDINAL[word]
+    if word.endswith("y"):
+        return word[:-1] + "ieth"
+    return word + "th"
+
+
+def _ordinal_words(n: int) -> str:
+    """English ordinal words for n (e.g. 3 -> 'third', 42 -> 'forty-second')."""
+    cardinal = _cardinal_words(n)
+    # Convert only the final word (handles 'forty-two'->'forty-second',
+    # 'one hundred seven'->'one hundred seventh').
+    if "-" in cardinal:
+        head, last = cardinal.rsplit("-", 1)
+        return f"{head}-{_to_ordinal_word(last)}"
+    parts = cardinal.rsplit(" ", 1)
+    if len(parts) == 2:
+        return f"{parts[0]} {_to_ordinal_word(parts[1])}"
+    return _to_ordinal_word(cardinal)
+
+
+async def _announce_paid_queued(api_gate, shadow, *, uid: int, title: str, username: str) -> None:
+    """Announce a paid queue placement to the channel chat.
+
+    Position is counted from the currently-playing item, wrapping around the
+    playlist (CyTube loops). The item immediately after now-playing reads
+    "next"; everything else uses an English ordinal counting the now-playing
+    item as first (so the item two slots away is "third").
+    """
+    items = shadow.items
+    np_uid = await _now_playing_uid(api_gate, shadow)
+    np_index = None
+    item_index = None
+    for i, it in enumerate(items):
+        if it.get("uid") == np_uid:
+            np_index = i
+        if it.get("uid") == uid:
+            item_index = i
+    if item_index is None:
         return
+    n = len(items)
+    offset = item_index if np_index is None else (item_index - np_index) % n
+    if offset <= 0:
+        return
+    position = "next" if offset == 1 else _ordinal_words(offset + 1)
     try:
-        await api_gate.send_chat(f"{title} has been queued in position {pos} by {username}")
+        await api_gate.send_chat(
+            f"{title} added to the queue with Zcoin by {username} and is now {position}."
+        )
     except Exception:
         logger.warning("Failed to send queue announcement", exc_info=True)
 
@@ -238,7 +305,7 @@ async def insert_pay_queue(
         )
 
         # Announce placement to the channel
-        await _announce_queued(api_gate, shadow, uid=uid, title=title, username=username)
+        await _announce_paid_queued(api_gate, shadow, uid=uid, title=title, username=username)
 
         return {"success": True, "uid": uid, "request_id": request_id}
 
@@ -351,7 +418,7 @@ async def insert_pay_playnext(
         )
 
         # Announce placement to the channel
-        await _announce_queued(api_gate, shadow, uid=uid, title=title, username=username)
+        await _announce_paid_queued(api_gate, shadow, uid=uid, title=title, username=username)
 
         return {"success": True, "uid": uid, "request_id": request_id}
 
@@ -479,8 +546,7 @@ async def insert_admin_queue(
             title=title, tier="admin", z_cost=0,
         )
 
-        # Announce placement to the channel
-        await _announce_queued(api_gate, shadow, uid=uid, title=title, username=username)
+        # Admin queueing is intentionally NOT announced in the channel.
 
         return {"success": True, "uid": uid, "refunded": removed}
 

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/kryten_webqueue/routes/admin_playlists.py

@@ -159,4 +159,5 @@ async def parse_text(request: Request, user: dict = Depends(require_admin)):
     body = await request.json()
     text = body.get("text", "")
     db = request.app.state.db
-    return await import_playlist_text(db, text)
+    config = request.app.state.config
+    return await import_playlist_text(db, text, mediacms_url=config.mediacms_url)

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/kryten_webqueue/templates/admin/playlists.html

@@ -49,9 +49,13 @@
                     <div id="cat-results" class="cat-results"></div>
 
                     <h3 style="margin-top:1.5rem;">Bulk Text Import</h3>
-                    <p class="muted" style="font-size:0.8rem;">One token per line. <code>cm:token</code>, <code>yt:id</code>, or a bare catalog token. <code>#</code> comments allowed.</p>
-                    <textarea id="import-text" class="import-text" rows="5" placeholder="abc123def&#10;yt:dQw4w9WgXcQ"></textarea>
-                    <button class="btn btn-sm" onclick="parseImport()">Append Parsed Items</button>
+                    <p class="muted" style="font-size:0.8rem;">One entry per line: a <strong>dropsugar.co</strong> link, a <strong>YouTube</strong>/<strong>youtu.be</strong> link (playlist &amp; start-time args are stripped), <code>cm:token</code>, <code>yt:id</code>, or a bare catalog token. <code>#</code> starts a comment (whole-line or trailing). Unknown sites are skipped.</p>
+                    <textarea id="import-text" class="import-text" rows="5" placeholder="https://www.dropsugar.co/view?m=abc123def&#10;https://youtu.be/dQw4w9WgXcQ?t=42  # start time is stripped&#10;yt:dQw4w9WgXcQ&#10;abc123def"></textarea>
+                    <div class="btn-group" style="margin-top:0.25rem;">
+                        <button class="btn btn-sm" onclick="parseImport()">Append Parsed Items</button>
+                        <input type="file" id="import-file" accept=".txt,.csv,text/plain" style="display:none" onchange="loadImportFile(event)">
+                        <button class="btn btn-sm" onclick="document.getElementById('import-file').click()">Choose text file…</button>
+                    </div>
                     <div id="import-errors" class="import-errors"></div>
                 </div>
             </div>
@@ -263,6 +267,22 @@ async function parseImport() {
     document.getElementById('import-text').value = '';
 }
 
+function loadImportFile(event) {
+    const file = event.target.files && event.target.files[0];
+    if (!file) return;
+    const reader = new FileReader();
+    reader.onload = () => {
+        const ta = document.getElementById('import-text');
+        // Append (with a newline separator) so the admin can review before parsing.
+        ta.value = (ta.value.trim() ? ta.value.replace(/\s*$/, '') + '\n' : '') + reader.result;
+        showToast(`Loaded ${file.name}`);
+    };
+    reader.onerror = () => showToast('Could not read file', 'error');
+    reader.readAsText(file);
+    // Reset so picking the same file again re-fires change.
+    event.target.value = '';
+}
+
 async function saveItems() {
     if (editorId === null) return;
     const resp = await fetch(`/admin/playlists/${editorId}/items`, {

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/kryten_webqueue/templates/admin/schedules.html

@@ -11,7 +11,7 @@
 
     <div class="admin-section">
         <div class="section-head">
-            <h2>Scheduled Fires</h2>
+            <h2>Scheduled Events</h2>
             <button class="btn btn-primary" onclick="showScheduleModal()">+ New Schedule</button>
         </div>
         <div id="schedules-list">Loading…</div>

{kryten_webqueue-0.9.5 → kryten_webqueue-0.9.7}/pyproject.toml

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

kryten_webqueue-0.9.7/tests/test_playlist_import.py

@@ -0,0 +1,136 @@
+"""Bulk text import parser (admin playlists) — v0.9.6.
+
+Covers dropsugar.co URL resolution, YouTube/youtu.be id extraction with arg
+stripping, comment handling (whole-line + inline), and tolerant skipping of
+unknown sites.
+"""
+
+import pytest
+
+from kryten_webqueue.catalog.db import Database
+from kryten_webqueue.playlists.importer import (
+    import_playlist_text,
+    extract_youtube_id,
+    extract_dropsugar_token,
+)
+
+MEDIACMS = "https://www.dropsugar.com"
+
+
+@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()
+
+
+async def _add_item(db, token, title="Title", *, duration=600):
+    await db.insert_catalog({
+        "friendly_token": token,
+        "title": title,
+        "description": "",
+        "duration_sec": duration,
+        "manifest_url": f"{MEDIACMS}/api/v1/media/cytube/{token}.json?format=json",
+        "thumbnail_url": "",
+        "synced_at": "2026-01-01T00:00:00+00:00",
+    })
+
+
+# --- pure URL helpers ---
+
+@pytest.mark.parametrize("url,expected", [
+    ("https://youtu.be/dQw4w9WgXcQ", "dQw4w9WgXcQ"),
+    ("https://youtu.be/dQw4w9WgXcQ?t=42", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/watch?v=dQw4w9WgXcQ", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/watch?v=dQw4w9WgXcQ&list=PL123&t=10", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/watch?list=PL123&v=dQw4w9WgXcQ", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/shorts/dQw4w9WgXcQ", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/embed/dQw4w9WgXcQ?start=5", "dQw4w9WgXcQ"),
+    ("https://www.youtube.com/playlist?list=PL123", None),
+])
+def test_extract_youtube_id(url, expected):
+    assert extract_youtube_id(url) == expected
+
+
+@pytest.mark.parametrize("url,expected", [
+    ("https://www.dropsugar.co/view?m=kBl82FCgy", "kBl82FCgy"),
+    ("https://www.dropsugar.co/view?m=kBl82FCgy&foo=bar", "kBl82FCgy"),
+    ("https://www.dropsugar.com/api/v1/media/cytube/abc123.json?format=json", "abc123"),
+    ("https://www.dropsugar.co/", None),
+])
+def test_extract_dropsugar_token(url, expected):
+    assert extract_dropsugar_token(url) == expected
+
+
+# --- full parse ---
+
+async def test_youtube_links_stripped_to_yt_items(db):
+    text = (
+        "https://youtu.be/dQw4w9WgXcQ?t=42\n"
+        "https://www.youtube.com/watch?v=abcdefghijk&list=PL9&t=3\n"
+    )
+    out = await import_playlist_text(db, text, mediacms_url=MEDIACMS)
+    assert [i["media_id"] for i in out["items"]] == ["dQw4w9WgXcQ", "abcdefghijk"]
+    assert all(i["media_type"] == "yt" for i in out["items"])
+    assert not out["errors"]
+
+
+async def test_dropsugar_url_resolves_catalog(db):
+    await _add_item(db, "kBl82FCgy", "Hollis Live")
+    out = await import_playlist_text(
+        db, "https://www.dropsugar.co/view?m=kBl82FCgy - Hollis Live on Channel-Z",
+        mediacms_url=MEDIACMS,
+    )
+    assert len(out["items"]) == 1
+    it = out["items"][0]
+    assert it["media_type"] == "cm"
+    assert it["media_id"] == f"{MEDIACMS}/api/v1/media/cytube/kBl82FCgy.json?format=json"
+    assert it["title"] == "Hollis Live"
+    assert not out["errors"]
+
+
+async def test_dropsugar_url_not_in_catalog_constructs_manifest(db):
+    out = await import_playlist_text(
+        db, "https://www.dropsugar.co/view?m=newtoken123 - Some Title",
+        mediacms_url=MEDIACMS,
+    )
+    assert len(out["items"]) == 1
+    it = out["items"][0]
+    assert it["media_type"] == "cm"
+    assert it["media_id"] == f"{MEDIACMS}/api/v1/media/cytube/newtoken123.json?format=json"
+    assert it["title"] == "Some Title"  # trailing text used as title hint
+
+
+async def test_comments_and_blanks_and_unknown_sites(db):
+    await _add_item(db, "good1")
+    text = (
+        "# a whole-line comment\n"
+        "\n"
+        "https://www.dropsugar.co/view?m=good1  # inline comment stripped\n"
+        "https://example.com/whatever\n"
+        "   \n"
+        "https://vimeo.com/12345 # unknown site\n"
+    )
+    out = await import_playlist_text(db, text, mediacms_url=MEDIACMS)
+    # Only the dropsugar line resolves; the two unknown sites are skipped.
+    assert len(out["items"]) == 1
+    assert out["items"][0]["media_id"].endswith("good1.json?format=json")
+    reasons = {e["reason"] for e in out["errors"]}
+    assert reasons == {"unsupported_site"}
+    assert len(out["errors"]) == 2
+
+
+async def test_legacy_tokens_still_work(db):
+    await _add_item(db, "bare1", "Bare One")
+    text = "yt:dQw4w9WgXcQ\ncm:cmtoken\nbare1\nunknownbare\n"
+    out = await import_playlist_text(db, text, mediacms_url=MEDIACMS)
+    yt = [i for i in out["items"] if i["media_type"] == "yt"]
+    cm = [i for i in out["items"] if i["media_type"] == "cm"]
+    assert yt[0]["media_id"] == "dQw4w9WgXcQ"
+    # bare1 resolves to its manifest URL; cm:cmtoken passes through.
+    assert any(i["media_id"].endswith("bare1.json?format=json") for i in cm)
+    assert any(i["media_id"] == "cmtoken" for i in cm)
+    # unknownbare is not in catalog -> error
+    assert any(e["token"] == "unknownbare" for e in out["errors"])

kryten_webqueue-0.9.7/tests/test_queue_announce.py

@@ -0,0 +1,106 @@
+"""Queue chat-announcement behaviour (v0.9.7).
+
+Covers the English-ordinal position words, the paid-queue announcement message
+format/position (counted from now-playing, wrapping), and that admin queueing
+is not announced.
+"""
+
+import pytest
+
+from kryten_webqueue.queue import ordering
+from kryten_webqueue.queue.ordering import _ordinal_words, _announce_paid_queued
+
+
+class _FakeApiGate:
+    def __init__(self, np_uid=None):
+        self.sent = []
+        self._np_uid = np_uid
+
+    async def get_now_playing(self):
+        return {"uid": self._np_uid} if self._np_uid is not None else None
+
+    async def send_chat(self, message):
+        self.sent.append(message)
+        return {"success": True}
+
+
+class _FakeShadow:
+    def __init__(self, items, now_playing=None):
+        self._items = items
+        self.now_playing = now_playing
+
+    @property
+    def items(self):
+        return self._items
+
+
+@pytest.mark.parametrize("n,word", [
+    (2, "second"),
+    (3, "third"),
+    (4, "fourth"),
+    (5, "fifth"),
+    (8, "eighth"),
+    (9, "ninth"),
+    (11, "eleventh"),
+    (12, "twelfth"),
+    (20, "twentieth"),
+    (21, "twenty-first"),
+    (42, "forty-second"),
+    (53, "fifty-third"),
+    (100, "one hundredth"),
+    (107, "one hundred seventh"),
+    (123, "one hundred twenty-third"),
+])
+def test_ordinal_words(n, word):
+    assert _ordinal_words(n) == word
+
+
+def _items(*uids):
+    return [{"uid": u, "title": f"Item {u}"} for u in uids]
+
+
+async def test_paid_announcement_next():
+    # now-playing uid=10 at index 0; the new item uid=11 is immediately next.
+    api = _FakeApiGate(np_uid=10)
+    shadow = _FakeShadow(_items(10, 11))
+    await _announce_paid_queued(api, shadow, uid=11, title="Airplane (1980)", username="Hollis")
+    assert api.sent == [
+        "Airplane (1980) added to the queue with Zcoin by Hollis and is now next."
+    ]
+
+
+async def test_paid_announcement_third():
+    # now-playing uid=10 at index 0; new item is two slots away -> "third".
+    api = _FakeApiGate(np_uid=10)
+    shadow = _FakeShadow(_items(10, 99, 11))
+    await _announce_paid_queued(api, shadow, uid=11, title="Airplane (1980)", username="Hollis")
+    assert api.sent == [
+        "Airplane (1980) added to the queue with Zcoin by Hollis and is now third."
+    ]
+
+
+async def test_paid_announcement_wraps_around():
+    # now-playing is uid=99 at index 2; list wraps: after 99 comes 10 (next),
+    # then 11 (third).
+    api = _FakeApiGate(np_uid=99)
+    shadow = _FakeShadow(_items(10, 11, 99))
+    await _announce_paid_queued(api, shadow, uid=11, title="X", username="U")
+    assert api.sent == ["X added to the queue with Zcoin by U and is now third."]
+
+
+async def test_admin_queue_not_announced(monkeypatch):
+    """insert_admin_queue must never call the announcement helper."""
+    called = False
+
+    async def _fail(*a, **k):
+        nonlocal called
+        called = True
+
+    monkeypatch.setattr(ordering, "_announce_paid_queued", _fail)
+    # Source check: the admin path has no announce call (the helper is only wired
+    # to the paid paths). This guards against a regression re-adding it.
+    import inspect
+    src = inspect.getsource(ordering.insert_admin_queue)
+    assert "_announce_paid_queued" not in src
+    assert "_announce_queued" not in src
+    assert called is False

kryten_webqueue-0.9.5/kryten_webqueue/playlists/importer.py

@@ -1,92 +0,0 @@
-import logging
-from datetime import datetime, UTC
-
-logger = logging.getLogger(__name__)
-
-
-class PlaylistImporter:
-    """Imports items from a saved playlist into the live CyTube queue."""
-
-    def __init__(self, *, api_gate, db, shadow):
-        self._api_gate = api_gate
-        self._db = db
-        self._shadow = shadow
-
-    async def import_playlist(self, playlist_id: int) -> dict:
-        """Import all 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"}
-
-        added = 0
-        errors = 0
-        for item in items:
-            try:
-                result = await self._api_gate.playlist_add(
-                    media_type=item["media_type"],
-                    media_id=item["media_id"],
-                    position="end",
-                )
-                if result.get("success"):
-                    added += 1
-                else:
-                    errors += 1
-            except Exception as e:
-                logger.warning(f"Failed to add {item['media_id']}: {e}")
-                errors += 1
-
-        return {"success": True, "added": added, "errors": errors}
-
-
-async def import_playlist_text(db, text: str) -> dict:
-    """Parse plain-text playlist import format.
-
-    Format:
-      - Lines starting with # are comments
-      - Blank lines are skipped
-      - "type:id" for explicit type (e.g. "yt:dQw4w9WgXcQ")
-      - "cm:friendly_token" for MediaCMS items
-      - Bare token resolves from catalog
-
-    Returns: {"items": [...], "errors": [...]}
-    """
-    items = []
-    errors = []
-
-    for line_num, line in enumerate(text.splitlines(), 1):
-        line = line.strip()
-        if not line or line.startswith("#"):
-            continue
-
-        if line.startswith("cm:"):
-            media_id = line[3:]
-            catalog_item = await db.get_item_admin(media_id)
-            items.append({
-                "media_type": "cm",
-                "media_id": media_id,
-                "title": catalog_item["title"] if catalog_item else None,
-                "duration_sec": catalog_item["duration_sec"] if catalog_item else None,
-            })
-        elif ":" in line:
-            # Explicit type:id (e.g. yt:abc123)
-            media_type, media_id = line.split(":", 1)
-            items.append({
-                "media_type": media_type,
-                "media_id": media_id,
-                "title": None,
-                "duration_sec": None,
-            })
-        else:
-            # Bare token — resolve from catalog
-            catalog_item = await db.get_item_admin(line)
-            if catalog_item:
-                items.append({
-                    "media_type": "cm",
-                    "media_id": catalog_item["friendly_token"],
-                    "title": catalog_item["title"],
-                    "duration_sec": catalog_item["duration_sec"],
-                })
-            else:
-                errors.append({"line": line_num, "token": line, "reason": "not_in_catalog"})
-
-    return {"items": items, "errors": errors}