kryten-webqueue 0.9.6__tar.gz → 0.9.8__tar.gz

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/CHANGELOG.md

@@ -6,6 +6,28 @@ 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.8] — 2026-06-12
+
+### Added
+
+- **`fetchurls` job now reads the Channel Z workbook from SharePoint** (Microsoft Graph) and **writes resolved dropsugar URLs back to column F**, restoring the original tool's full round-trip. The service authenticates *silently* from a pre-seeded MSAL token cache and never prompts interactively. A one-time sign-in helper seeds the cache: `python -m kryten_webqueue.jobs.fetchurls_auth` (also installed as `kryten-webqueue-fetchurls-auth`). It prints a device-code URL; sign in once and the ~90-day refresh token is cached for unattended runs. If the cache is missing/expired the job fails with a clear "run fetchurls_auth" message.
+  - New config under `fetchurls`: `sharepoint_tenant_id`, `sharepoint_client_id`, `sharepoint_sharing_url`, `token_cache_path`. A local `workbook_path` (or a per-run `workbook_path` param) still works as a fallback/override.
+  - New `writeback` job parameter (default on) controls column-F writeback; `dry_run` and local-file mode skip it.
+  - Added `msal` as a core dependency.
+- **`fetchurls` imports into three fixed, well-known playlists** — `Friday Night`, `Saturday Morning`, `Saturday Night` — instead of date-prefixed names. The playlists are matched by name (any creator), their items replaced in place on every run (idempotent), and their existing immutability preserved; if a playlist is missing it is (re)created as immutable so the reserved status is retained.
+
+### Fixed
+
+- Bulk/`cm:` playlist imports for items not yet in the local catalog (e.g. freshly downloaded by `fetch`/`fetchurls` before a sync) now construct the CyTube manifest URL from the token instead of leaving a bare token that wouldn't play.
+
+## [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

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryten-webqueue
-Version: 0.9.6
+Version: 0.9.8
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT
@@ -10,6 +10,7 @@ Requires-Dist: apscheduler>=3.10
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: jinja2>=3.1
+Requires-Dist: msal>=1.28
 Requires-Dist: openpyxl>=3.1
 Requires-Dist: pillow>=10.0
 Requires-Dist: pydantic>=2.0

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/config.example.json

@@ -16,7 +16,11 @@
 
   "fetch_cookies_path": "",
   "fetchurls": {
-    "workbook_path": ""
+    "workbook_path": "",
+    "sharepoint_tenant_id": "",
+    "sharepoint_client_id": "",
+    "sharepoint_sharing_url": "",
+    "token_cache_path": "/var/lib/kryten-webqueue/.fetchurls_tokens.bin"
   },
 
   "db_path": "/var/lib/kryten-webqueue/webqueue.db",

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/kryten_webqueue/catalog/db.py

@@ -956,6 +956,19 @@ class Database:
             [name, created_by],
         )
 
+    async def get_playlist_by_name_any(self, name: str) -> dict | None:
+        """Match an existing saved playlist by exact name, any creator.
+
+        Used for the fetchurls fixed section playlists ("Friday Night",
+        "Saturday Morning", "Saturday Night") which pre-exist (possibly created
+        by a different admin) and must be reused/replaced in place rather than
+        duplicated.
+        """
+        return await self._fetch_one(
+            "SELECT * FROM saved_playlists WHERE name=? ORDER BY id LIMIT 1",
+            [name],
+        )
+
     # --- Schedules ---
 
     async def get_schedules(self) -> list[dict]:

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/kryten_webqueue/config.py

@@ -4,9 +4,22 @@ import json
 
 
 class FetchUrlsConfig(BaseModel):
-    """Settings for the fetchurls job (v1 = local file only, OQ-1)."""
+    """Settings for the fetchurls job.
 
-    workbook_path: str = ""  # absolute path to a synced Channel Z Playlist .xlsx
+    Reads the Channel Z workbook from SharePoint (Microsoft Graph) when the
+    SharePoint fields are configured, otherwise falls back to a local ``.xlsx``
+    at ``workbook_path``. SharePoint auth uses a pre-seeded MSAL token cache
+    (see ``python -m kryten_webqueue.jobs.fetchurls_auth``); the service only
+    acquires tokens *silently* from that cache and never prompts interactively.
+    """
+
+    workbook_path: str = ""  # local .xlsx fallback (used when SharePoint unset)
+
+    # SharePoint / Microsoft Graph (read workbook + write resolved URLs to col F)
+    sharepoint_tenant_id: str = ""
+    sharepoint_client_id: str = ""
+    sharepoint_sharing_url: str = ""
+    token_cache_path: str = ""  # MSAL cache file, pre-seeded out-of-band
 
 
 class Config(BaseModel):

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/kryten_webqueue/integrations/cmsutils/fetchurls.py

@@ -287,6 +287,43 @@ def acquire_graph_token(tenant_id: str, client_id: str, cache_path: str = "") ->
     return result["access_token"]
 
 
+def acquire_graph_token_silent(tenant_id: str, client_id: str, cache_path: str) -> Optional[str]:
+    """Return a Graph access token from a pre-seeded MSAL cache, or None.
+
+    Unlike :func:`acquire_graph_token`, this NEVER prompts interactively — it is
+    safe to call from the headless webqueue service. The cache must have been
+    seeded out-of-band (``python -m kryten_webqueue.jobs.fetchurls_auth``). A
+    None return means the admin must (re)authenticate.
+    """
+    if not _HAS_MSAL:
+        raise RuntimeError(
+            "fetchurls SharePoint integration requires 'msal'. "
+            "Install the optional extra: pip install 'kryten-webqueue[jobs]'"
+        )
+    if not cache_path:
+        return None
+    cache_file = Path(cache_path)
+    if not cache_file.exists():
+        return None
+    token_cache = msal.SerializableTokenCache()
+    token_cache.deserialize(cache_file.read_text(encoding="utf-8"))
+    app = msal.PublicClientApplication(
+        client_id,
+        authority=f"https://login.microsoftonline.com/{tenant_id}",
+        token_cache=token_cache,
+    )
+    accounts = app.get_accounts()
+    if not accounts:
+        return None
+    result = app.acquire_token_silent(GRAPH_SCOPES, account=accounts[0])
+    if token_cache.has_state_changed:
+        cache_file.write_text(token_cache.serialize(), encoding="utf-8")
+    if result and "access_token" in result:
+        return result["access_token"]
+    return None
+
+
+
 def _encode_sharing_url(url: str) -> str:
     """Encode a SharePoint sharing/document URL for use with the Graph shares API."""
     encoded = base64.urlsafe_b64encode(url.encode()).decode().rstrip("=")
@@ -1269,13 +1306,21 @@ def _make_inprocess_fetch(config):
 
 
 def run(params: dict, *, config, progress=None) -> dict:
-    """Resolve the upcoming weekend's Channel Z workbook into playlist files.
+    """Resolve the upcoming weekend's Channel Z workbook into playlist sections.
+
+    Source precedence:
+      1. ``params['workbook_path']`` (one-off local override, e.g. for tests)
+      2. SharePoint via Microsoft Graph when ``config.fetchurls.sharepoint_*``
+         are set (token acquired *silently* from the pre-seeded MSAL cache)
+      3. ``config.fetchurls.workbook_path`` (local file fallback)
 
-    File-only (OQ-1): reads a local ``.xlsx`` (``params['workbook_path']`` or
-    ``config.fetchurls.workbook_path``); no SharePoint/Graph/MSAL, no column-F
-    writeback. Off-site URLs are downloaded via the in-process yt-pipe
-    downloader. Returns counts + per-section resolved ``cm:`` lines for the job
-    wrapper to import as saved playlists.
+    When the source is SharePoint and ``writeback`` is on (and not a dry run),
+    resolved dropsugar URLs are written back to column F via the Graph Excel
+    API. Off-site URLs are downloaded via the in-process yt-pipe downloader.
+
+    Returns counts plus, per section slug, the resolved ``cm:`` lines and the
+    human label ("Friday Night", etc.) so the job wrapper can import each into a
+    fixed, well-known saved playlist.
     """
     _check_openpyxl()
     import openpyxl as _oxl  # noqa: F811 - explicit local import for clarity
@@ -1283,23 +1328,51 @@ def run(params: dict, *, config, progress=None) -> dict:
     section = params.get("section") or "all"
     dry_run = bool(params.get("dry_run", False))
     validate = bool(params.get("validate", True))
-
-    cfg_fetchurls = getattr(config, "fetchurls", None)
-    cfg_path = ""
-    if cfg_fetchurls is not None:
-        cfg_path = getattr(cfg_fetchurls, "workbook_path", "") or ""
-    workbook_path = params.get("workbook_path") or cfg_path
-    if not workbook_path:
-        raise RuntimeError("fetchurls requires a workbook path (config.fetchurls.workbook_path)")
-    wb_file = Path(workbook_path)
-    if not wb_file.exists():
-        raise RuntimeError(f"Workbook not found: {wb_file}")
+    writeback = bool(params.get("writeback", True))
 
     def _emit(detail):
         if progress:
             progress(detail)
 
-    wb_bytes = wb_file.read_bytes()
+    cfg = getattr(config, "fetchurls", None)
+    local_override = params.get("workbook_path") or ""
+    sp_tenant = getattr(cfg, "sharepoint_tenant_id", "") if cfg else ""
+    sp_client = getattr(cfg, "sharepoint_client_id", "") if cfg else ""
+    sp_share = getattr(cfg, "sharepoint_sharing_url", "") if cfg else ""
+    sp_cache = getattr(cfg, "token_cache_path", "") if cfg else ""
+    cfg_local = getattr(cfg, "workbook_path", "") if cfg else ""
+
+    use_sharepoint = bool(sp_tenant and sp_client and sp_share) and not local_override
+
+    wb_ctx = None
+    drive_id = item_id = ""
+    graph_token = ""
+
+    if use_sharepoint:
+        _emit({"phase": "auth", "source": "sharepoint"})
+        graph_token = acquire_graph_token_silent(sp_tenant, sp_client, sp_cache)
+        if not graph_token:
+            raise RuntimeError(
+                "SharePoint authentication unavailable: no valid token in the MSAL "
+                "cache. Run a one-time sign-in on the server: "
+                "python -m kryten_webqueue.jobs.fetchurls_auth"
+            )
+        _emit({"phase": "download", "source": "sharepoint"})
+        try:
+            wb_bytes, drive_id, item_id = download_sharepoint_xlsx(graph_token, sp_share)
+        except SystemExit as exc:  # the vendored reader uses sys.exit on failure
+            raise RuntimeError(f"SharePoint download failed: {exc}") from exc
+    else:
+        workbook_path = local_override or cfg_local
+        if not workbook_path:
+            raise RuntimeError(
+                "fetchurls needs a workbook source: configure "
+                "fetchurls.sharepoint_* (recommended) or fetchurls.workbook_path."
+            )
+        wb_file = Path(workbook_path)
+        if not wb_file.exists():
+            raise RuntimeError(f"Workbook not found: {wb_file}")
+        wb_bytes = wb_file.read_bytes()
 
     sheet_name, friday, saturday = upcoming_weekend_sheet()
     wb_peek = _oxl.load_workbook(io.BytesIO(wb_bytes), read_only=True)
@@ -1316,6 +1389,14 @@ def run(params: dict, *, config, progress=None) -> dict:
     if section and section != "all":
         sections = {k: v for k, v in sections.items() if k == section}
 
+    # Build the writeback context (SharePoint only, non-dry-run, writeback on).
+    if use_sharepoint and writeback and not dry_run:
+        wb_ctx = WritebackContext(
+            token=graph_token, drive_id=drive_id, item_id=item_id,
+            sheet_name=sheet_name, dry_run=False,
+            tenant_id=sp_tenant, client_id=sp_client, cache_path=sp_cache,
+        )
+
     # Swap in the in-process fetch (no fetch.ps1 subprocess in a service).
     global run_fetch  # noqa: PLW0603
     original_run_fetch = run_fetch
@@ -1328,15 +1409,17 @@ def run(params: dict, *, config, progress=None) -> dict:
     downloaded = 0
     failures = 0
     section_lines: dict[str, list[str]] = {}
+    section_labels: dict[str, str] = {}
     all_results: dict[str, list[ProcessResult]] = {}
 
     try:
         for slug, url_rows in sections.items():
             if not url_rows:
                 continue
-            label = SECTION_LABELS.get(slug, slug) if "SECTION_LABELS" in globals() else slug
+            label = SECTION_LABELS.get(slug, slug)
+            section_labels[slug] = label
             results = process_section(
-                label, url_rows, Path("."), dry_run, validate, wb_ctx=None,
+                label, url_rows, Path("."), dry_run, validate, wb_ctx=wb_ctx,
             )
             all_results[slug] = results
             write_playlist(out_dir / f"{sheet_name}-{slug}.txt", results)
@@ -1354,14 +1437,26 @@ def run(params: dict, *, config, progress=None) -> dict:
         write_failures(out_dir / f"{sheet_name}-failures.txt", all_results)
     finally:
         run_fetch = original_run_fetch
+        if wb_ctx is not None:
+            try:
+                _close_workbook_session(wb_ctx)
+            except Exception:  # noqa: BLE001 - best-effort cleanup
+                pass
+
+    writeback_stats = None
+    if wb_ctx is not None:
+        writeback_stats = {"ok": wb_ctx.writes_ok, "failed": wb_ctx.writes_fail}
 
     _emit({"phase": "done", "sheet": sheet_name, "resolved": resolved, "failures": failures})
     return {
         "sheet": sheet_name,
+        "source": "sharepoint" if use_sharepoint else "local",
         "resolved": resolved,
         "downloaded": downloaded,
         "failures": failures,
+        "writeback": writeback_stats,
         "section_lines": section_lines,
+        "section_labels": section_labels,
         "imported_playlists": [],  # filled in by the async job wrapper
         "dry_run": dry_run,
     }

kryten_webqueue-0.9.8/kryten_webqueue/jobs/fetchurls_auth.py

@@ -0,0 +1,62 @@
+"""One-time SharePoint sign-in for the fetchurls job.
+
+The webqueue service only acquires Microsoft Graph tokens *silently* from a
+pre-seeded MSAL cache (it never prompts). Run this once on the server to create
+that cache via the device-code flow:
+
+    python -m kryten_webqueue.jobs.fetchurls_auth [--config /path/to/config.json]
+
+It prints a URL + code; sign in with the curiousmotors account and grant the
+Files.ReadWrite.All consent. The refresh token is cached (~90 days) at
+``fetchurls.token_cache_path`` so subsequent unattended job runs authenticate
+silently. Re-run this when the cache expires.
+"""
+
+import argparse
+import os
+import sys
+
+from ..config import Config
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="One-time SharePoint sign-in for fetchurls")
+    parser.add_argument(
+        "--config",
+        default=os.environ.get("WQ_CONFIG", "/etc/kryten-webqueue/config.json"),
+        help="Path to the webqueue config.json (default: $WQ_CONFIG or /etc/kryten-webqueue/config.json)",
+    )
+    args = parser.parse_args(argv)
+
+    config = Config.from_file(args.config)
+    fu = config.fetchurls
+    if not (fu.sharepoint_tenant_id and fu.sharepoint_client_id):
+        print(
+            "ERROR: fetchurls.sharepoint_tenant_id and sharepoint_client_id must be "
+            "set in the config before authenticating.",
+            file=sys.stderr,
+        )
+        return 2
+    if not fu.token_cache_path:
+        print(
+            "ERROR: fetchurls.token_cache_path must be set so the token can be cached "
+            "for the service to reuse.",
+            file=sys.stderr,
+        )
+        return 2
+
+    from ..integrations.cmsutils.fetchurls import acquire_graph_token
+
+    token = acquire_graph_token(
+        fu.sharepoint_tenant_id, fu.sharepoint_client_id, fu.token_cache_path
+    )
+    if token:
+        print(f"\n✓ Authenticated. Token cached at: {fu.token_cache_path}")
+        print("  The fetchurls job can now run unattended until the cache expires.")
+        return 0
+    print("ERROR: Authentication did not complete.", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/kryten_webqueue/jobs/tasks.py

@@ -121,33 +121,43 @@ async def fetch_job(params: dict, ctx):
 # ── fetchurls job ──────────────────────────────────────────────────────────────
 
 async def _import_section_as_playlist(ctx, name: str, lines: list[str], triggered_by: str) -> dict | None:
-    """Import resolved ``cm:`` lines as a saved playlist, idempotent by name.
+    """Import resolved ``cm:`` lines into a fixed, well-known saved playlist.
 
-    Re-running replaces the items of an existing same-named playlist (matched
-    by name + creator) rather than creating a duplicate.
+    The three fetchurls playlists ("Friday Night", "Saturday Morning",
+    "Saturday Night") pre-exist and are immutable. We match by **name only**
+    (any creator), replace their items in place (idempotent re-runs), and
+    preserve their existing immutability. If a playlist is missing it is created
+    as immutable so a recreated playlist keeps the reserved status.
     """
     from ..playlists.importer import import_playlist_text
 
     if not lines:
         return None
-    parsed = await import_playlist_text(ctx.db, "\n".join(lines))
+    parsed = await import_playlist_text(
+        ctx.db, "\n".join(lines), mediacms_url=ctx.config.mediacms_url
+    )
     items = parsed.get("items") or []
     if not items:
         return None
 
-    existing = await ctx.db.get_playlist_by_name(name, triggered_by)
+    existing = await ctx.db.get_playlist_by_name_any(name)
     if existing:
         playlist_id = existing["id"]
     else:
         playlist_id = await ctx.db.create_saved_playlist(
-            name=name, description=None, is_immutable=False, created_by=triggered_by,
+            name=name, description=None, is_immutable=True, created_by=triggered_by,
         )
     await ctx.db.replace_playlist_items(playlist_id, items)
     return {"id": playlist_id, "name": name, "count": len(items)}
 
 
 async def fetchurls_job(params: dict, ctx):
-    """Resolve the upcoming-weekend workbook, then import each section playlist."""
+    """Resolve the upcoming-weekend workbook, then import each section playlist.
+
+    Sections map to the fixed playlists by their human label:
+      friday → "Friday Night", saturday-morning → "Saturday Morning",
+      saturday-night → "Saturday Night".
+    """
     result = await _run_vendored(
         "kryten_webqueue.integrations.cmsutils.fetchurls", params, ctx,
         deps=["openpyxl", "yaml", "requests"],
@@ -156,16 +166,17 @@ async def fetchurls_job(params: dict, ctx):
     if result.get("dry_run"):
         return result
 
-    sheet = result.get("sheet")
     triggered_by = ctx.triggered_by or "system"
+    labels = result.get("section_labels") or {}
     imported = []
     for slug, lines in (result.get("section_lines") or {}).items():
-        name = f"{sheet}-{slug}"
+        name = labels.get(slug) or slug
         info = await _import_section_as_playlist(ctx, name, lines, triggered_by)
         if info:
             imported.append(info["name"])
     result["imported_playlists"] = imported
     result.pop("section_lines", None)  # keep the persisted detail compact
+    result.pop("section_labels", None)
     return result
 
 
@@ -210,5 +221,6 @@ FETCHURLS_SCHEMA = [
      "options": ["all", "friday", "saturday-night", "saturday-morning"], "label": "Section"},
     {"name": "dry_run", "type": "bool", "default": False, "label": "Dry run (resolve only)"},
     {"name": "validate", "type": "bool", "default": True, "label": "Validate existing URLs"},
-    {"name": "workbook_path", "type": "string", "default": None, "label": "Workbook path (override)"},
+    {"name": "writeback", "type": "bool", "default": True, "label": "Write resolved URLs back to SharePoint (col F)"},
+    {"name": "workbook_path", "type": "string", "default": None, "label": "Local workbook path (override SharePoint)"},
 ]

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/kryten_webqueue/playlists/importer.py

@@ -179,9 +179,16 @@ async def import_playlist_text(db, text: str, *, mediacms_url: str | None = None
         if line.startswith("cm:"):
             media_id = line[3:].strip()
             catalog_item = await db.get_item_admin(media_id)
+            if catalog_item:
+                resolved_media = catalog_item["manifest_url"]
+            else:
+                # Not yet in the local catalog (e.g. freshly downloaded by the
+                # fetch/fetchurls job before a sync) — construct the CyTube
+                # manifest URL from the token so it still plays.
+                resolved_media = _manifest_url_for_token(media_id, mediacms_url) or media_id
             items.append({
                 "media_type": "cm",
-                "media_id": catalog_item["manifest_url"] if catalog_item else media_id,
+                "media_id": resolved_media,
                 "title": catalog_item["title"] if catalog_item else None,
                 "duration_sec": catalog_item["duration_sec"] if catalog_item else None,
             })

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/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.6 → kryten_webqueue-0.9.8}/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.6 → kryten_webqueue-0.9.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryten-webqueue"
-version = "0.9.6"
+version = "0.9.8"
 description = "Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube"
 readme = "README.md"
 license = "MIT"
@@ -25,6 +25,7 @@ dependencies = [
     "requests>=2.31",
     "pyyaml>=6.0",
     "python-slugify>=8.0",
+    "msal>=1.28",
 ]
 
 [project.optional-dependencies]
@@ -39,6 +40,7 @@ dev = [
 
 [project.scripts]
 kryten-webqueue = "kryten_webqueue.__main__:main"
+kryten-webqueue-fetchurls-auth = "kryten_webqueue.jobs.fetchurls_auth:main"
 
 [build-system]
 requires = ["hatchling"]

kryten_webqueue-0.9.8/tests/test_fetchurls_sharepoint.py

@@ -0,0 +1,135 @@
+"""fetchurls SharePoint + fixed-name playlist behaviour (v0.9.8).
+
+Covers the silent-token guard, source selection / clear error when the MSAL
+cache is unseeded, the fixed section-label playlist names, immutable-preserve on
+re-import, and the importer ``cm:`` manifest-URL fallback.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from kryten_webqueue.catalog.db import Database
+from kryten_webqueue.jobs.manager import JobContext
+from kryten_webqueue.jobs import tasks
+from kryten_webqueue.integrations.cmsutils import fetchurls
+from kryten_webqueue.playlists.importer import import_playlist_text
+
+
+@pytest.fixture
+async def db(tmp_path):
+    database = Database(str(tmp_path / "fu.db"))
+    await database.connect()
+    await database.run_migrations()
+    yield database
+    await database.close()
+
+
+def _config(**fu):
+    return SimpleNamespace(
+        mediacms_url="https://cms.example",
+        mediacms_token="tok",
+        tmdb_api_key="", omdb_api_key="",
+        image_dir="/tmp/kqimg",
+        fetch_cookies_path="",
+        fetchurls=SimpleNamespace(
+            workbook_path=fu.get("workbook_path", ""),
+            sharepoint_tenant_id=fu.get("sharepoint_tenant_id", ""),
+            sharepoint_client_id=fu.get("sharepoint_client_id", ""),
+            sharepoint_sharing_url=fu.get("sharepoint_sharing_url", ""),
+            token_cache_path=fu.get("token_cache_path", ""),
+        ),
+    )
+
+
+def _ctx(db, config=None):
+    return JobContext(db=db, api_gate=None, config=config or _config(), run_id=1, triggered_by="admin")
+
+
+# --- silent token guard ---
+
+def test_silent_token_none_without_cache(tmp_path):
+    missing = str(tmp_path / "nope.bin")
+    assert fetchurls.acquire_graph_token_silent("tenant", "client", missing) is None
+    assert fetchurls.acquire_graph_token_silent("tenant", "client", "") is None
+
+
+# --- run() source selection / clear error ---
+
+def test_run_sharepoint_without_token_raises_clear_error(tmp_path):
+    config = _config(
+        sharepoint_tenant_id="t", sharepoint_client_id="c",
+        sharepoint_sharing_url="https://sp/share",
+        token_cache_path=str(tmp_path / "absent.bin"),
+    )
+    with pytest.raises(RuntimeError, match="fetchurls_auth"):
+        fetchurls.run({}, config=config, progress=None)
+
+
+def test_run_no_source_raises(tmp_path):
+    with pytest.raises(RuntimeError, match="workbook source"):
+        fetchurls.run({}, config=_config(), progress=None)
+
+
+# --- fixed section-label playlist names + immutable preserve ---
+
+async def _add_catalog(db, token, title="T"):
+    await db.insert_catalog({
+        "friendly_token": token, "title": title, "description": "",
+        "duration_sec": 600, "manifest_url": f"https://cms/api/v1/media/cytube/{token}.json",
+        "thumbnail_url": "", "synced_at": "2026-01-01T00:00:00+00:00",
+    })
+
+
+async def test_fetchurls_job_uses_fixed_label_names(db, monkeypatch):
+    await _add_catalog(db, "f1")
+    await _add_catalog(db, "s1")
+
+    async def fake_run_vendored(module_path, params, ctx, *, deps):
+        return {
+            "sheet": "3.6-3.7", "dry_run": False, "resolved": 2, "failures": 0,
+            "section_lines": {"friday": ["cm:f1"], "saturday-night": ["cm:s1"]},
+            "section_labels": {"friday": "Friday Night", "saturday-night": "Saturday Night"},
+        }
+
+    monkeypatch.setattr(tasks, "_run_vendored", fake_run_vendored)
+    result = await tasks.fetchurls_job({}, _ctx(db))
+
+    assert sorted(result["imported_playlists"]) == ["Friday Night", "Saturday Night"]
+    names = {p["name"] for p in await db.get_saved_playlists()}
+    assert {"Friday Night", "Saturday Night"} <= names
+    # Created playlists are immutable (reserved).
+    fri = await db.get_playlist_by_name_any("Friday Night")
+    assert fri["is_immutable"] == 1
+
+
+async def test_fetchurls_import_preserves_existing_immutability(db, monkeypatch):
+    await _add_catalog(db, "f1")
+    await _add_catalog(db, "f2")
+    # Pre-existing MUTABLE playlist with the fixed name, created by someone else.
+    pid = await db.create_saved_playlist(
+        name="Friday Night", description=None, is_immutable=False, created_by="other-admin",
+    )
+
+    info = await tasks._import_section_as_playlist(_ctx(db), "Friday Night", ["cm:f1", "cm:f2"], "admin")
+    assert info["id"] == pid                      # reused, not duplicated
+    pl = await db.get_playlist_by_name_any("Friday Night")
+    assert pl["is_immutable"] == 0                # existing flag preserved (not forced)
+    assert pl["created_by"] == "other-admin"      # original owner kept
+    items = await db.get_saved_playlist_items(pid)
+    assert len(items) == 2
+
+
+# --- importer cm: manifest fallback for not-yet-synced items ---
+
+async def test_importer_cm_fallback_builds_manifest(db):
+    out = await import_playlist_text(db, "cm:freshtoken", mediacms_url="https://cms.example")
+    assert len(out["items"]) == 1
+    assert out["items"][0]["media_id"] == "https://cms.example/api/v1/media/cytube/freshtoken.json?format=json"
+
+
+async def test_importer_cm_uses_catalog_when_present(db):
+    await _add_catalog(db, "known", "Known Title")
+    out = await import_playlist_text(db, "cm:known", mediacms_url="https://cms.example")
+    assert out["items"][0]["media_id"] == "https://cms/api/v1/media/cytube/known.json"
+    assert out["items"][0]["title"] == "Known Title"

{kryten_webqueue-0.9.6 → kryten_webqueue-0.9.8}/tests/test_playlist_import.py

@@ -129,8 +129,9 @@ async def test_legacy_tokens_still_work(db):
     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.
+    # bare1 resolves to its manifest URL; cm:cmtoken (not in catalog) now falls
+    # back to a constructed manifest URL so not-yet-synced items still play.
     assert any(i["media_id"].endswith("bare1.json?format=json") for i in cm)
-    assert any(i["media_id"] == "cmtoken" for i in cm)
+    assert any(i["media_id"] == f"{MEDIACMS}/api/v1/media/cytube/cmtoken.json?format=json" for i in cm)
     # unknownbare is not in catalog -> error
     assert any(e["token"] == "unknownbare" for e in out["errors"])

kryten_webqueue-0.9.8/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