kryten-webqueue 0.44.6__tar.gz → 0.45.0__tar.gz

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## [0.45.0] - 2026-09-10
+
+### Added
+
+- **`motd_publish` job** — builds the weekend poster grid from the schedule
+  workbook and sets the channel Message of the Day through api-gate's
+  `PUT /admin/motd`. Each curator title (`Title (YYYY)`) is resolved to an IMDb
+  tt# and poster art; positions with no title yet, or a title that can't be
+  verified, render as **mystery boxes** so the grid is always complete and
+  self-heals on the next run once the title is fixed. A missing or unreadable
+  workbook degrades to an all-mystery grid rather than failing the run.
+- **Per-week MOTD slot overrides** (migration **v30**, `motd_overrides`). An
+  admin can pin a hand-picked title, curator-supplied art, or a non-IMDb link
+  for any grid position; overrides always beat the lookup and retire on their
+  own when the workbook week rolls over. New admin API under `/admin/motd`:
+  `GET` (preview the resolved grid + live MOTD), `GET /render`,
+  `PUT`/`DELETE /overrides/{slot_key}`, `POST /overrides/{slot_key}/art`
+  (alternate-art upload), and `POST /publish`.
+- **Admin MOTD page** at `/admin/motd` (linked from the admin nav): shows the
+  resolved grid night by night with a resolved/override/mystery badge per slot,
+  an override editor (title, link, poster URL, or an art upload), an
+  HTML preview, the currently-live MOTD, and a one-click publish.
+- **Early debut.** The workbook sheet rolls forward on Monday; `week=next`
+  (job param and admin query string) publishes the coming weekend's grid on
+  Sunday, while weekend traffic is still watching.
+- **`fetchurls` now chains `motd_publish`** (new `publish_motd` param, on by
+  default) — a curator's corrected title re-publishes the MOTD in the same
+  pass. Best-effort: a MOTD failure never fails URL resolution.
+- **Next-event context.** The rendered snippet carries the next armed playlist
+  schedule (`label`, `starts_in`), laying the groundwork for swapping the MOTD
+  on each scheduled playlist fire.
+- `ApiGateClient.set_motd()`; `MOTDConfig` gained `template`, `slots`,
+  `banner_url`, `headline`, `showtime`, `mystery_box_url`, `mystery_box_href`,
+  `links`, and `upload_max_bytes` (see `config.example.json`).
+
+### Security
+
+- The MOTD template renders with Jinja autoescape on and a `safe_url` filter
+  that rejects any non-`http(s)` URL, so untrusted curator titles and override
+  links can't inject markup or `javascript:` URLs into the channel MOTD. Slot
+  keys are regex-validated and art uploads are restricted by content type and
+  size.
+
+## [0.44.7] - 2026-08-31
+
+### Fixed
+
+- **SQLite WAL corruption mitigation.** The catalog DB connection now sets
+  `synchronous=NORMAL` (safe in WAL mode), `busy_timeout=5000` (retry on
+  lock contention instead of failing immediately), `wal_autocheckpoint=100`
+  (checkpoint every 100 pages instead of the 1000-page default, keeping the
+  WAL small), and runs a passive checkpoint on every connect to drain any
+  stale frames left by an unclean previous run.
+- **`delete_stale_catalog_items` rewritten to use subqueries.** Previously
+  built a potentially huge `IN (?, ?, …)` parameter list (one bind for every
+  stale token) before issuing two separate bulk DELETEs. Now uses correlated
+  subqueries instead, eliminating the SELECT round-trip and the large
+  parameter list, reducing per-sync WAL pressure.
+
 ## [0.44.6] - 2026-08-30
 
 ### Fixed

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kryten-webqueue
-Version: 0.44.6
+Version: 0.45.0
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT
@@ -17,6 +17,7 @@ Requires-Dist: pycryptodomex>=3.20
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyjwt>=2.8
 Requires-Dist: python-dateutil>=2.8
+Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: python-slugify>=8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.31

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/config.example.json

@@ -86,5 +86,26 @@
     "inter_emote_delay_sec": 2.0
   },
 
+  "motd": {
+    "poster_dir": "/home/mediacms.io/mediacms/static/motd_boxes",
+    "poster_base_url": "https://www.dropsugar.co/static/motd_boxes",
+    "output_dir": "~/kryten",
+    "template": "channel_z.html",
+    "slots": 12,
+    "banner_url": "https://i.postimg.cc/jdr2mR8Y/1562479186-8-channel-Ztitlenew.png",
+    "headline": "CHANNEL Z WEEKEND MOVIE PLAYLIST ({dates})",
+    "showtime": "6pm ET",
+    "mystery_box_url": "https://www.dropsugar.co/static/motd_boxes/mystery-box.jpg",
+    "mystery_box_href": "https://queue.dropsugar.co/",
+    "upload_max_bytes": 5242880,
+    "links": [
+      { "label": "Join us on Reddit!", "url": "https://www.reddit.com/r/Channel_Z/" },
+      {
+        "label": "See the queue and decide what's next!",
+        "url": "https://queue.dropsugar.co/"
+      }
+    ]
+  },
+
   "prometheus_port": 28292
 }

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/api_gate/client.py

@@ -108,6 +108,9 @@ class ApiGateClient:
         result = await self.get("/admin/motd")
         return result.get("motd", "")
 
+    async def set_motd(self, motd: str) -> dict:
+        return await self.put("/admin/motd", json={"motd": motd})
+
     # --- Economy proxy ---
 
     async def get_balance(self, username: str) -> dict:

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/app.py

@@ -32,6 +32,7 @@ from .routes.admin_playlists import router as admin_playlists_router
 from .routes.admin_schedules import router as admin_schedules_router
 from .routes.admin_queue import router as admin_queue_router
 from .routes.admin_jobs import router as admin_jobs_router
+from .routes.admin_motd import router as admin_motd_router
 from .routes.admin_job_schedules import router as admin_job_schedules_router
 from .routes.admin_catalog import router as admin_catalog_router
 from .routes.admin_promos import router as admin_promos_router
@@ -167,6 +168,14 @@ async def lifespan(app: FastAPI):
         label="MOTD Posters (weekend poster grid)",
         schema=MOTD_POSTERS_SCHEMA,
     )
+    from .jobs.motd_publish import motd_publish_job, MOTD_PUBLISH_SCHEMA
+
+    job_manager.register(
+        "motd_publish",
+        motd_publish_job,
+        label="MOTD Publish (build grid & set channel MOTD)",
+        schema=MOTD_PUBLISH_SCHEMA,
+    )
     job_manager.register(
         "tmdb_index_refresh",
         tmdb_index_refresh_job,
@@ -418,6 +427,7 @@ def create_app(config: Config) -> FastAPI:
     app.include_router(admin_schedules_router)
     app.include_router(admin_queue_router)
     app.include_router(admin_jobs_router)
+    app.include_router(admin_motd_router)
     app.include_router(admin_job_schedules_router)
     app.include_router(admin_catalog_router)
     app.include_router(admin_promos_router)

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/catalog/db/__init__.py

@@ -14,6 +14,7 @@ from ._enrichment import _EnrichmentMixin
 from ._fetch_queue import _FetchQueueMixin
 from ._blackouts import _BlackoutMixin
 from ._devices import _DevicesMixin
+from ._motd import _MOTDMixin
 
 
 class Database(
@@ -27,6 +28,7 @@ class Database(
     _FetchQueueMixin,
     _BlackoutMixin,
     _DevicesMixin,
+    _MOTDMixin,
     _DBBase,
 ):
     """Async SQLite database wrapper."""

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/catalog/db/_catalog.py

@@ -1042,30 +1042,22 @@ class _CatalogMixin:
         - catalog_people
         - catalog_studios
         """
-        cursor = await self._db.execute(
-            "SELECT friendly_token FROM catalog WHERE synced_at < ? OR synced_at IS NULL",
-            [sync_started_at],
-        )
-        tokens = [row[0] for row in await cursor.fetchall()]
-
-        if not tokens:
-            return 0
-
-        # Delete from FTS first (not automatically cascaded)
-        placeholders = ",".join("?" * len(tokens))
+        # Delete from FTS first (not automatically cascaded); use subquery to avoid
+        # building a potentially huge IN-list parameter list for large syncs.
         await self._db.execute(
-            f"DELETE FROM catalog_fts WHERE friendly_token IN ({placeholders})",
-            tokens,
+            "DELETE FROM catalog_fts WHERE friendly_token IN "
+            "(SELECT friendly_token FROM catalog WHERE synced_at < ? OR synced_at IS NULL)",
+            [sync_started_at],
         )
 
         # Delete from catalog (cascades to join tables via ON DELETE CASCADE)
-        await self._db.execute(
-            f"DELETE FROM catalog WHERE friendly_token IN ({placeholders})",
-            tokens,
+        cursor = await self._db.execute(
+            "DELETE FROM catalog WHERE synced_at < ? OR synced_at IS NULL",
+            [sync_started_at],
         )
-
+        count = cursor.rowcount
         await self._db.commit()
-        return len(tokens)
+        return count or 0
 
     async def find_catalog_by_title(self, title: str) -> dict | None:
         """Best-effort lookup of a catalog item whose title matches ``title``.

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/catalog/db/_connection.py

@@ -533,6 +533,25 @@ MIGRATIONS = [
     );
     CREATE INDEX IF NOT EXISTS idx_job_run_logs_run ON job_run_logs(run_id, seq);
     """,
+    # v30: Per-week MOTD slot overrides. The motd_publish job resolves the
+    # weekend line-up from the workbook automatically; a row here pins one grid
+    # position for one week (curator-supplied art, a hand-picked title, or a
+    # non-IMDb link) and always wins over the auto-resolved value. Keyed on the
+    # workbook sheet name (e.g. '8.14-8.15') plus the stable slot key
+    # ('night1-slot3'), so re-running the job is idempotent and the overrides
+    # retire naturally once that week rolls off.
+    """
+    CREATE TABLE IF NOT EXISTS motd_overrides (
+        week_key   TEXT NOT NULL,
+        slot_key   TEXT NOT NULL,
+        title      TEXT,
+        poster_url TEXT,
+        href       TEXT,
+        created_by TEXT,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (week_key, slot_key)
+    );
+    """,
 ]
 
 
@@ -549,6 +568,16 @@ class _DBBase:
         self._db.row_factory = aiosqlite.Row
         await self._db.execute("PRAGMA journal_mode=WAL")
         await self._db.execute("PRAGMA foreign_keys=ON")
+        await self._db.execute(
+            "PRAGMA synchronous=NORMAL"
+        )  # safe in WAL; faster than FULL
+        await self._db.execute("PRAGMA busy_timeout=5000")  # retry up to 5 s on lock
+        await self._db.execute(
+            "PRAGMA wal_autocheckpoint=100"
+        )  # checkpoint every 100 pages
+        await self._db.execute(
+            "PRAGMA wal_checkpoint(PASSIVE)"
+        )  # drain any stale WAL on open
 
     async def close(self):
         if self._db:

kryten_webqueue-0.45.0/kryten_webqueue/catalog/db/_motd.py

@@ -0,0 +1,55 @@
+class _MOTDMixin:
+    """Per-week MOTD slot override CRUD (see migration v30).
+
+    An override pins one position of the weekend poster grid for one workbook
+    week. Any of ``title`` / ``poster_url`` / ``href`` may be NULL, in which
+    case the auto-resolved value for that field is kept.
+    """
+
+    async def upsert_motd_override(
+        self,
+        week_key: str,
+        slot_key: str,
+        *,
+        title: str | None = None,
+        poster_url: str | None = None,
+        href: str | None = None,
+        created_by: str | None = None,
+    ) -> None:
+        """Insert or update one slot override, merging with any existing row."""
+        await self._db.execute(
+            """
+            INSERT INTO motd_overrides
+                (week_key, slot_key, title, poster_url, href, created_by, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(week_key, slot_key) DO UPDATE SET
+                title      = COALESCE(excluded.title, motd_overrides.title),
+                poster_url = COALESCE(excluded.poster_url, motd_overrides.poster_url),
+                href       = COALESCE(excluded.href, motd_overrides.href),
+                created_by = excluded.created_by,
+                updated_at = CURRENT_TIMESTAMP
+            """,
+            [week_key, slot_key, title, poster_url, href, created_by],
+        )
+        await self._db.commit()
+
+    async def list_motd_overrides(self, week_key: str) -> list[dict]:
+        return await self._fetch_all(
+            "SELECT * FROM motd_overrides WHERE week_key = ? ORDER BY slot_key",
+            [week_key],
+        )
+
+    async def delete_motd_override(self, week_key: str, slot_key: str) -> int:
+        cursor = await self._db.execute(
+            "DELETE FROM motd_overrides WHERE week_key = ? AND slot_key = ?",
+            [week_key, slot_key],
+        )
+        await self._db.commit()
+        return cursor.rowcount or 0
+
+    async def clear_motd_overrides(self, week_key: str) -> int:
+        cursor = await self._db.execute(
+            "DELETE FROM motd_overrides WHERE week_key = ?", [week_key]
+        )
+        await self._db.commit()
+        return cursor.rowcount or 0

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/config.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from pydantic import BaseModel, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr
 import json
 
 
@@ -21,8 +21,15 @@ class EmoteRehostConfig(BaseModel):
     inter_emote_delay_sec: float = 2.0
 
 
+class MOTDLink(BaseModel):
+    """A footer link rendered under the MOTD poster grid."""
+
+    label: str
+    url: str
+
+
 class MOTDConfig(BaseModel):
-    """Settings for the MOTD poster generator job."""
+    """Settings for the MOTD poster generator and publisher jobs."""
 
     # Filesystem path where poster images are written.
     poster_dir: str = "/home/mediacms.io/mediacms/static/motd_boxes"
@@ -31,6 +38,32 @@ class MOTDConfig(BaseModel):
     # Directory where the generated HTML snippet is written.
     output_dir: str = "~/kryten"
 
+    # --- motd_publish ---
+    # Jinja template under kryten_webqueue/templates/motd/.
+    template: str = "channel_z.html"
+    # Grid size; unresolved positions are filled with mystery boxes.
+    slots: int = 12
+    banner_url: str = "https://i.postimg.cc/jdr2mR8Y/1562479186-8-channel-Ztitlenew.png"
+    # {dates} is substituted with the weekend showtimes (e.g. "8/14 @ 6pm ET & ...").
+    headline: str = "CHANNEL Z WEEKEND MOVIE PLAYLIST ({dates})"
+    showtime: str = "6pm ET"
+    mystery_box_url: str = "https://www.dropsugar.co/static/motd_boxes/mystery-box.jpg"
+    mystery_box_href: str = "https://queue.dropsugar.co/"
+    links: list[MOTDLink] = Field(
+        default_factory=lambda: [
+            MOTDLink(
+                label="Join us on Reddit!",
+                url="https://www.reddit.com/r/Channel_Z/",
+            ),
+            MOTDLink(
+                label="See the queue and decide what's next!",
+                url="https://queue.dropsugar.co/",
+            ),
+        ]
+    )
+    # Max size accepted by the admin alternate-art upload endpoint.
+    upload_max_bytes: int = 5 * 1024 * 1024
+
 
 class FetchUrlsConfig(BaseModel):
     """Settings for the fetchurls job.

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/integrations/cmsutils/motdposters.py

@@ -225,6 +225,67 @@ def _poster_filename(date: datetime.date, movie_idx: int, night: int) -> str:
     return f"art-{date:%Y-%m-%d}-movie{movie_idx}-night{night}.jpg"
 
 
+def load_workbook_bytes(config, *, local_override: str = "", emit=None) -> bytes:
+    """Read the Channel Z workbook from SharePoint, or a local .xlsx fallback.
+
+    Mirrors ``fetchurls.run()``'s source resolution so every workbook-backed job
+    honours the same credentials and local-override precedence.
+    """
+
+    def _say(detail: dict) -> None:
+        if emit:
+            emit(detail)
+
+    fu = getattr(config, "fetchurls", None)
+    sp_tenant: str = getattr(fu, "sharepoint_tenant_id", "") if fu else ""
+    sp_client: str = getattr(fu, "sharepoint_client_id", "") if fu else ""
+    sp_share: str = getattr(fu, "sharepoint_sharing_url", "") if fu else ""
+    sp_cache: str = getattr(fu, "token_cache_path", "") if fu else ""
+    cfg_local: str = getattr(fu, "workbook_path", "") if fu else ""
+
+    if bool(sp_tenant and sp_client and sp_share) and not local_override:
+        _say({"phase": "auth"})
+        graph_token = acquire_graph_token_silent(sp_tenant, sp_client, sp_cache)
+        if not graph_token:
+            raise RuntimeError(
+                "SharePoint token unavailable — run: "
+                "python -m kryten_webqueue.jobs.fetchurls_auth"
+            )
+        _say({"phase": "download"})
+        wb_bytes, _, _ = download_sharepoint_xlsx(graph_token, sp_share)
+        return wb_bytes
+
+    workbook_path = local_override or cfg_local
+    if not workbook_path:
+        raise RuntimeError(
+            "No workbook source: configure fetchurls.sharepoint_* or "
+            "fetchurls.workbook_path"
+        )
+    wb_file = Path(workbook_path)
+    if not wb_file.exists():
+        raise RuntimeError(f"Workbook not found: {wb_file}")
+    return wb_file.read_bytes()
+
+
+def resolve_weekend_sheet(wb_bytes: bytes, sheet_name: str) -> None:
+    """Raise a helpful RuntimeError when the expected weekend sheet is absent."""
+    try:
+        import openpyxl
+    except ImportError:
+        raise RuntimeError("openpyxl is required to read the weekend workbook")
+
+    wb_peek = openpyxl.load_workbook(io.BytesIO(wb_bytes), read_only=True)
+    all_sheets = wb_peek.sheetnames
+    wb_peek.close()
+    if sheet_name in all_sheets:
+        return
+    weekend_sheets = [s for s in all_sheets if _SHEET_DATE_RE.match(s.strip())]
+    raise RuntimeError(
+        f"Weekend sheet '{sheet_name}' not found. "
+        f"Available: {', '.join(weekend_sheets or all_sheets)}"
+    )
+
+
 def _generate_html(night_entries: list[dict], poster_base_url: str) -> str:
     """Build the <div class="poster-grid"> snippet from processed entries."""
     base = poster_base_url.rstrip("/")

kryten_webqueue-0.45.0/kryten_webqueue/jobs/motd_publish.py

@@ -0,0 +1,198 @@
+"""MOTD publish job — build the weekend poster grid and set the channel MOTD.
+
+Resolves the current weekend's line-up from the schedule workbook, downloads
+poster art, renders the Jinja snippet, and pushes it to CyTube through
+api-gate's ``PUT /admin/motd``. Unresolvable or not-yet-scheduled positions
+become mystery boxes, so a run always produces a complete grid and self-heals
+on the next run once a curator fixes a title.
+
+Admin-supplied per-slot overrides (custom art, hand-picked title, non-IMDb
+link) are stored per workbook week and always win over the lookup.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import datetime
+import logging
+from pathlib import Path
+
+from ..motd.builder import build_slots
+from ..motd.render import render_motd
+from .manager import JobError
+
+logger = logging.getLogger(__name__)
+
+MOTD_PUBLISH_SCHEMA = [
+    {
+        "name": "publish",
+        "label": "Publish to channel",
+        "type": "bool",
+        "default": True,
+        "required": False,
+        "help": "Push the rendered snippet to CyTube's MOTD. Turn off to only write the HTML file.",
+    },
+    {
+        "name": "dry_run",
+        "label": "Dry run (render only)",
+        "type": "bool",
+        "default": False,
+        "required": False,
+        "help": "Resolve titles and render the snippet without downloading art, writing files, or touching the channel.",
+    },
+    {
+        "name": "refresh_art",
+        "label": "Re-download poster art",
+        "type": "bool",
+        "default": False,
+        "required": False,
+        "help": "Fetch poster art again even when the file already exists on disk.",
+    },
+    {
+        "name": "week",
+        "label": "Which weekend",
+        "type": "enum",
+        "default": "current",
+        "required": False,
+        "options": [
+            {"value": "current", "label": "This weekend (rolls over Monday)"},
+            {
+                "value": "next",
+                "label": "Next weekend — debut early, while weekend traffic is still here",
+            },
+        ],
+        "help": "The sheet rolls forward on Monday; pick 'next' to publish the coming weekend's grid on Sunday.",
+    },
+    {
+        "name": "workbook_path",
+        "label": "Local workbook path (override SharePoint)",
+        "type": "string",
+        "default": None,
+        "required": False,
+    },
+]
+
+
+def _humanize_delta(seconds: float) -> str:
+    if seconds < 90:
+        return "starting now"
+    minutes = int(seconds // 60)
+    if minutes < 60:
+        return f"in {minutes} min"
+    hours, minutes = divmod(minutes, 60)
+    if hours < 24:
+        return f"in {hours}h {minutes:02d}m" if minutes else f"in {hours}h"
+    days = hours // 24
+    return f"in {days} day{'s' if days != 1 else ''}"
+
+
+async def _next_event(db) -> dict | None:
+    """Summarise the next armed playlist schedule for the MOTD context."""
+    row = await db.get_next_schedule()
+    if not row:
+        return None
+    fire_at = row.get("fire_at")
+    starts_in = ""
+    try:
+        when = datetime.datetime.fromisoformat(str(fire_at).replace("Z", "+00:00"))
+        if when.tzinfo is None:
+            when = when.replace(tzinfo=datetime.timezone.utc)
+        delta = (when - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
+        if delta > 0:
+            starts_in = _humanize_delta(delta)
+    except (TypeError, ValueError):
+        logger.debug("motd_publish: unparseable fire_at %r", fire_at)
+    return {
+        "schedule_id": row.get("id"),
+        "playlist_id": row.get("playlist_id"),
+        "label": row.get("label") or "Scheduled event",
+        "fire_at": fire_at,
+        "starts_in": starts_in,
+    }
+
+
+async def motd_publish_job(params: dict, ctx) -> dict:
+    """Build, render, and publish the weekend MOTD."""
+    dry_run = bool(params.get("dry_run", False))
+    publish = bool(params.get("publish", True)) and not dry_run
+    refresh_art = bool(params.get("refresh_art", False))
+    workbook_path = params.get("workbook_path") or ""
+    week_offset = 1 if params.get("week") == "next" else 0
+
+    from ..motd.builder import week_context
+
+    week_key, _ = week_context(week_offset=week_offset)
+    overrides = {
+        row["slot_key"]: row for row in await ctx.db.list_motd_overrides(week_key)
+    }
+
+    loop = asyncio.get_running_loop()
+
+    def _emit(detail: dict) -> None:
+        asyncio.run_coroutine_threadsafe(ctx.progress(detail), loop)
+
+    try:
+        week = await asyncio.to_thread(
+            build_slots,
+            ctx.config,
+            overrides=overrides,
+            workbook_path=workbook_path,
+            refresh_art=refresh_art,
+            dry_run=dry_run,
+            week_offset=week_offset,
+            emit=_emit,
+        )
+    except RuntimeError as exc:
+        raise JobError(str(exc)) from exc
+
+    next_event = await _next_event(ctx.db)
+    html = render_motd(ctx.config, week, next_event=next_event)
+
+    output_path: str | None = None
+    if not dry_run:
+        out_dir = Path(ctx.config.motd.output_dir).expanduser()
+        out_dir.mkdir(parents=True, exist_ok=True)
+        target = out_dir / f"motd-{week.week_key}.html"
+        await asyncio.to_thread(target.write_text, html, encoding="utf-8")
+        output_path = str(target)
+        logger.info("motd_publish: wrote snippet → %s", target)
+
+    published = False
+    if publish:
+        try:
+            await ctx.api_gate.set_motd(html)
+            published = True
+            logger.info("motd_publish: MOTD updated for %s", week.week_key)
+        except Exception as exc:  # noqa: BLE001 - surfaced as a job failure message
+            raise JobError(f"Failed to set channel MOTD: {exc}") from exc
+
+    resolved = sum(1 for s in week.slots if s.resolved)
+    overridden = sum(1 for s in week.slots if s.source == "override")
+    mystery = [s.slot_key for s in week.slots if not s.resolved]
+
+    logger.info(
+        "motd_publish: %s — %d/%d slots resolved (%d overridden, %d mystery)",
+        week.week_key,
+        resolved,
+        len(week.slots),
+        overridden,
+        len(mystery),
+    )
+
+    result = {
+        "week_key": week.week_key,
+        "slots": len(week.slots),
+        "resolved": resolved,
+        "overridden": overridden,
+        "mystery": len(mystery),
+        "mystery_slots": mystery,
+        "workbook_found": week.workbook_found,
+        "warnings": week.warnings,
+        "next_event": next_event,
+        "published": published,
+        "output_path": output_path,
+        "dry_run": dry_run,
+        "html_bytes": len(html),
+    }
+    await ctx.progress({"phase": "complete", **result})
+    return result

{kryten_webqueue-0.44.6 → kryten_webqueue-0.45.0}/kryten_webqueue/jobs/tasks.py

@@ -521,6 +521,19 @@ async def fetchurls_job(params: dict, ctx):
             pm.get("failed", 0),
         )
 
+    # Curators fix titles in the workbook, so a fetchurls pass is exactly when a
+    # previously-unresolvable MOTD slot becomes resolvable. Best-effort: a MOTD
+    # failure must not fail the URL resolution that already succeeded.
+    if params.get("publish_motd", True) and ctx.job_manager:
+        try:
+            await ctx.job_manager.run(
+                "motd_publish", triggered_by=ctx.triggered_by or "fetchurls"
+            )
+            result["motd_publish_started"] = True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("fetchurls: could not start motd_publish: %s", exc)
+            result["motd_publish_started"] = False
+
     return result
 
 
@@ -649,6 +662,12 @@ FETCHURLS_SCHEMA = [
         "default": None,
         "label": "Local workbook path (override SharePoint)",
     },
+    {
+        "name": "publish_motd",
+        "type": "bool",
+        "default": True,
+        "label": "Re-publish the weekend MOTD afterwards",
+    },
 ]
 
 MOTD_POSTERS_SCHEMA = [