kryten-webqueue 0.32.3__tar.gz → 0.33.1__tar.gz

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.33.1] — 2026-07-29
+
+### Changed
+
+- **Applied `black` formatting across the codebase.** Repository-wide `black` pass (default profile) to bring all source and test modules — including the vendored `integrations/cmsutils/*` tools — into a consistent style. No behavioral changes; purely cosmetic.
+
+## [0.33.0] — 2026-07-29
+
+### Added
+
+- **Sunday schedule in the "Fetch URLs (weekend workbook)" job.** `fetchurls` now resolves two additional column-A sections from the weekend workbook: `SUNDAY MORNING` → the **"Sunday Morning"** saved playlist (slug `sunday-morning`), and `SUNDAY AFTERNOON` → the **"Sunday Daytime"** saved playlist (slug `sunday-daytime`). The two new sections join the existing Friday/Saturday sections and are resolved and imported the same way (dropsugar.co validated via HEAD; YouTube/Tubi auto-downloaded and posted to the CMS). The job's `section` parameter gains `sunday-morning` and `sunday-daytime` options (`all` still runs every section). Sunday lives in the existing `M.D-M.D` weekend sheet as extra rows — the worksheet naming scheme is unchanged (first sheet with Sunday rows is `8.7-8.8`).
+
 ## [0.32.3] — 2026-07-09
 
 ### Fixed

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/PKG-INFO

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

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/docs/SPEC_JOBS_AND_BROWSE.md

@@ -146,14 +146,14 @@ Reimplements `fetchurls.py`: read the Channel Z Excel workbook from SharePoint,
 
 | Field | Type | Default | Notes |
 |-------|------|---------|-------|
-| `section` | enum | `all` | `all` \| `friday` \| `saturday-night` \| `saturday-morning`. |
+| `section` | enum | `all` | `all` \| `friday` \| `saturday-night` \| `saturday-morning` \| `sunday-morning` \| `sunday-daytime`. |
 | `dry_run` | bool | `false` | Resolve/preview only; no downloads, no writeback, no import. |
 | `writeback` | bool | `true` | Write resolved URLs back to column F. |
 | `validate` | bool | `true` | HEAD-check existing dropsugar.co URLs. |
 
 **Import resulting playlists (new):**
-- The tool produces `playlists/{sheet}-friday.txt`, `{sheet}-saturday-night.txt`, `{sheet}-saturday-morning.txt`, and `{sheet}-failures.txt`.
-- After a successful (non-dry-run) run, **import each non-failures file as a saved playlist** named exactly like the file stem: `{sheet}-friday`, `{sheet}-saturday-night`, `{sheet}-saturday-morning`. Reuse `import_playlist_text()` to resolve lines, then `create_saved_playlist(name=stem, created_by=triggered_by)` + `replace_playlist_items()`.
+- The tool produces `playlists/{sheet}-friday.txt`, `{sheet}-saturday-night.txt`, `{sheet}-saturday-morning.txt`, `{sheet}-sunday-morning.txt`, `{sheet}-sunday-daytime.txt`, and `{sheet}-failures.txt`.
+- After a successful (non-dry-run) run, **import each non-failures file as a saved playlist** named exactly like the file stem: `{sheet}-friday`, `{sheet}-saturday-night`, `{sheet}-saturday-morning`, `{sheet}-sunday-morning`, `{sheet}-sunday-daytime`. Reuse `import_playlist_text()` to resolve lines, then `create_saved_playlist(name=stem, created_by=triggered_by)` + `replace_playlist_items()`.
 - If a playlist of that name already exists, **replace its items** (idempotent re-runs) rather than creating a duplicate. (Match by exact name + `created_by`.)
 - The `{sheet}-failures` file is **not** imported; surface its count in the run detail.
 

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/api_gate/client.py

@@ -59,14 +59,24 @@ class ApiGateClient:
 
     # --- Playlist CRUD ---
 
-    async def playlist_add(self, media_type: str, media_id: str, *, position: str = "end", temp: bool = True) -> dict:
+    async def playlist_add(
+        self,
+        media_type: str,
+        media_id: str,
+        *,
+        position: str = "end",
+        temp: bool = True,
+    ) -> dict:
         """Add item to playlist. Returns {"success": bool, "uid": int|None}."""
-        return await self.post("/playlist/add", json={
-            "type": media_type,
-            "id": media_id,
-            "position": position,
-            "temp": temp,
-        })
+        return await self.post(
+            "/playlist/add",
+            json={
+                "type": media_type,
+                "id": media_id,
+                "position": position,
+                "temp": temp,
+            },
+        )
 
     async def playlist_move(self, uid: int, position: int | str) -> dict:
         """Move item. position is a UID (int) or "prepend"/"append"."""
@@ -87,7 +97,9 @@ class ApiGateClient:
         return await self.post("/chat/send", json={"message": message})
 
     async def send_pm(self, username: str, message: str) -> dict:
-        return await self.post("/chat/pm", json={"username": username, "message": message})
+        return await self.post(
+            "/chat/pm", json={"username": username, "message": message}
+        )
 
     # --- Admin ---
 
@@ -100,51 +112,77 @@ class ApiGateClient:
     async def get_balance(self, username: str) -> dict:
         return await self.get(f"/economy/balance/{username}")
 
-    async def get_transactions(self, username: str, limit: int = 20, offset: int = 0) -> dict:
-        return await self.get(f"/economy/transactions/{username}", limit=limit, offset=offset)
+    async def get_transactions(
+        self, username: str, limit: int = 20, offset: int = 0
+    ) -> dict:
+        return await self.get(
+            f"/economy/transactions/{username}", limit=limit, offset=offset
+        )
 
     async def get_account_summary(self, username: str) -> dict:
         return await self.get(f"/economy/account/{username}")
 
     async def set_vanity_greeting(self, username: str, value: str) -> dict:
-        return await self.post("/economy/vanity/greeting", json={
-            "username": username,
-            "value": value,
-        })
+        return await self.post(
+            "/economy/vanity/greeting",
+            json={
+                "username": username,
+                "value": value,
+            },
+        )
 
     async def set_vanity_color(self, username: str, value: str) -> dict:
-        return await self.post("/economy/vanity/color", json={
-            "username": username,
-            "value": value,
-        })
+        return await self.post(
+            "/economy/vanity/color",
+            json={
+                "username": username,
+                "value": value,
+            },
+        )
 
     async def set_vanity_shoutout(self, username: str, value: str) -> dict:
-        return await self.post("/economy/vanity/shoutout", json={
-            "username": username,
-            "value": value,
-        })
-
-    async def queue_preview(self, username: str, duration_sec: int, tier: str = "queue") -> dict:
-        return await self.post("/economy/queue-preview", json={
-            "username": username,
-            "duration_sec": duration_sec,
-            "tier": tier,
-        })
-
-    async def queue_spend(self, username: str, duration_sec: int, tier: str, request_id: str) -> dict:
-        return await self.post("/economy/queue-spend", json={
-            "username": username,
-            "duration_sec": duration_sec,
-            "tier": tier,
-            "request_id": request_id,
-        })
+        return await self.post(
+            "/economy/vanity/shoutout",
+            json={
+                "username": username,
+                "value": value,
+            },
+        )
+
+    async def queue_preview(
+        self, username: str, duration_sec: int, tier: str = "queue"
+    ) -> dict:
+        return await self.post(
+            "/economy/queue-preview",
+            json={
+                "username": username,
+                "duration_sec": duration_sec,
+                "tier": tier,
+            },
+        )
+
+    async def queue_spend(
+        self, username: str, duration_sec: int, tier: str, request_id: str
+    ) -> dict:
+        return await self.post(
+            "/economy/queue-spend",
+            json={
+                "username": username,
+                "duration_sec": duration_sec,
+                "tier": tier,
+                "request_id": request_id,
+            },
+        )
 
     async def queue_refund(self, username: str, request_id: str, reason: str) -> dict:
-        return await self.post("/economy/queue-refund", json={
-            "username": username,
-            "request_id": request_id,
-            "reason": reason,
-        })
+        return await self.post(
+            "/economy/queue-refund",
+            json={
+                "username": username,
+                "request_id": request_id,
+                "reason": reason,
+            },
+        )
 
     # --- Moderator service status ---
 
@@ -159,7 +197,9 @@ class ApiGateClient:
 
     # --- Moderation entries ---
 
-    async def mod_list_entries(self, channel: str, action_filter: str | None = None) -> dict:
+    async def mod_list_entries(
+        self, channel: str, action_filter: str | None = None
+    ) -> dict:
         params: dict = {}
         if action_filter:
             params["filter"] = action_filter
@@ -206,12 +246,15 @@ class ApiGateClient:
 
     async def mod_remove_pattern(self, channel: str, pattern: str) -> dict:
         from urllib.parse import quote
+
         encoded = quote(pattern, safe="")
         return await self.delete(f"/channels/{channel}/patterns/{encoded}")
 
     # --- Recent users ---
 
-    async def mod_recent_users(self, channel: str, window_minutes: float = 60.0) -> dict:
+    async def mod_recent_users(
+        self, channel: str, window_minutes: float = 60.0
+    ) -> dict:
         return await self.get(
             f"/channels/{channel}/users/recent", window_minutes=window_minutes
         )

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/app.py

@@ -59,7 +59,8 @@ async def lifespan(app: FastAPI):
     if purged["completions"] or purged["playlist_pass"]:
         logger.info(
             "Purged promo recently-played state: %d completion(s), %d pass row(s)",
-            purged["completions"], purged["playlist_pass"],
+            purged["completions"],
+            purged["playlist_pass"],
         )
     # Any job run still marked 'running' is an orphan from a prior crash/restart
     # (the running flag is in-memory only). Reconcile before registering jobs.
@@ -108,21 +109,42 @@ async def lifespan(app: FastAPI):
     # register regardless of optional deps; a missing dep fails the run fast
     # with a clear message rather than crashing startup.
     from .jobs.tasks import (
-        enrichtitles_job, enrichmeta_job, enrichtv_job,
-        fetch_job, fetchurls_job,
-        ENRICHTITLES_SCHEMA, ENRICHMETA_SCHEMA, ENRICHTV_SCHEMA,
-        FETCH_SCHEMA, FETCHURLS_SCHEMA,
+        enrichtitles_job,
+        enrichmeta_job,
+        enrichtv_job,
+        fetch_job,
+        fetchurls_job,
+        ENRICHTITLES_SCHEMA,
+        ENRICHMETA_SCHEMA,
+        ENRICHTV_SCHEMA,
+        FETCH_SCHEMA,
+        FETCHURLS_SCHEMA,
+    )
+
+    job_manager.register(
+        "enrichtitles",
+        enrichtitles_job,
+        label="Enrich Titles",
+        schema=ENRICHTITLES_SCHEMA,
+    )
+    job_manager.register(
+        "enrichmeta",
+        enrichmeta_job,
+        label="Enrich Movie Metadata",
+        schema=ENRICHMETA_SCHEMA,
+    )
+    job_manager.register(
+        "enrichtv", enrichtv_job, label="Enrich TV Metadata", schema=ENRICHTV_SCHEMA
+    )
+    job_manager.register(
+        "fetch", fetch_job, label="Fetch (download → MediaCMS)", schema=FETCH_SCHEMA
+    )
+    job_manager.register(
+        "fetchurls",
+        fetchurls_job,
+        label="Fetch URLs (weekend workbook)",
+        schema=FETCHURLS_SCHEMA,
     )
-    job_manager.register("enrichtitles", enrichtitles_job,
-                         label="Enrich Titles", schema=ENRICHTITLES_SCHEMA)
-    job_manager.register("enrichmeta", enrichmeta_job,
-                         label="Enrich Movie Metadata", schema=ENRICHMETA_SCHEMA)
-    job_manager.register("enrichtv", enrichtv_job,
-                         label="Enrich TV Metadata", schema=ENRICHTV_SCHEMA)
-    job_manager.register("fetch", fetch_job,
-                         label="Fetch (download → MediaCMS)", schema=FETCH_SCHEMA)
-    job_manager.register("fetchurls", fetchurls_job,
-                         label="Fetch URLs (weekend workbook)", schema=FETCHURLS_SCHEMA)
     app.state.job_manager = job_manager
 
     # WebSocket manager
@@ -143,7 +165,10 @@ async def lifespan(app: FastAPI):
 
     # Promo director (poller-driven; also used synchronously by the pay path)
     promo_director = PromoDirector(
-        api_gate=api_gate, db=db, shadow=shadow, config=config.promos,
+        api_gate=api_gate,
+        db=db,
+        shadow=shadow,
+        config=config.promos,
         add_delay_sec=config.playlist_bulk_add_delay_sec,
         add_max_retries=config.playlist_bulk_add_max_retries,
     )
@@ -174,7 +199,10 @@ async def lifespan(app: FastAPI):
 
     # Playlist scheduler
     scheduler = PlaylistScheduler(
-        db=db, api_gate=api_gate, shadow=shadow, ws_manager=ws_manager,
+        db=db,
+        api_gate=api_gate,
+        shadow=shadow,
+        ws_manager=ws_manager,
         add_delay_sec=config.playlist_bulk_add_delay_sec,
         add_max_retries=config.playlist_bulk_add_max_retries,
         promo_director=promo_director,
@@ -184,7 +212,10 @@ async def lifespan(app: FastAPI):
 
     # Presence-based cancel/refund monitor
     presence_monitor = PresenceRefundMonitor(
-        api_gate=api_gate, shadow=shadow, db=db, ws_manager=ws_manager,
+        api_gate=api_gate,
+        shadow=shadow,
+        db=db,
+        ws_manager=ws_manager,
         config=config.presence_refund,
     )
     await presence_monitor.start()
@@ -215,7 +246,8 @@ async def lifespan(app: FastAPI):
         while True:
             await asyncio.sleep(300)  # every 5 minutes
             try:
-                await db._execute("""
+                await db._execute(
+                    """
                     UPDATE saved_playlists SET is_immutable = 0
                     WHERE id IN (
                         SELECT sp.id FROM saved_playlists sp
@@ -230,7 +262,8 @@ async def lifespan(app: FastAPI):
                                 AND (ps2.immutability_expires_at IS NULL OR ps2.immutability_expires_at > datetime('now'))
                           )
                     )
-                """)
+                """
+                )
             except Exception as e:
                 logger.error(f"Immutability expiry error: {e}")
 
@@ -240,7 +273,9 @@ async def lifespan(app: FastAPI):
         asyncio.create_task(_immutability_expiry_loop()),
     ]
 
-    logger.info(f"kryten-webqueue v{__version__} started on {config.host}:{config.port}")
+    logger.info(
+        f"kryten-webqueue v{__version__} started on {config.host}:{config.port}"
+    )
 
     yield
 

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/auth/session.py

@@ -3,7 +3,9 @@ from datetime import datetime, timedelta, UTC
 from fastapi import Request, HTTPException
 
 
-def create_session_token(username: str, rank: int, secret_key: str, ttl_hours: int = 24) -> str:
+def create_session_token(
+    username: str, rank: int, secret_key: str, ttl_hours: int = 24
+) -> str:
     payload = {
         "sub": username,
         "rank": rank,

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/catalog/db/__init__.py

@@ -1,5 +1,10 @@
 from ._connection import _DBBase
-from ._catalog import _CatalogMixin, HIDDEN_ITEM_TAG, HIDDEN_CATEGORY_NAMES, HIDDEN_TAG_NAMES
+from ._catalog import (
+    _CatalogMixin,
+    HIDDEN_ITEM_TAG,
+    HIDDEN_CATEGORY_NAMES,
+    HIDDEN_TAG_NAMES,
+)
 from ._playlists import _PlaylistsMixin
 from ._queue import _QueueMixin
 from ._feedback import _FeedbackMixin

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/catalog/db/_catalog.py

@@ -133,7 +133,9 @@ def _recently_played_exclusion(alias: str, days: int) -> tuple[str, list]:
     return sql, [f"-{int(days)} days"]
 
 
-def _facet_filter(alias: str, category: str | None, tag: str | None) -> tuple[str, list]:
+def _facet_filter(
+    alias: str, category: str | None, tag: str | None
+) -> tuple[str, list]:
     """SQL fragment (+ params) AND-filtering by a category slug and/or tag name.
 
     Each filter is an ``AND friendly_token IN (...)`` subquery on the catalog row
@@ -191,7 +193,17 @@ class _CatalogMixin:
 
     # --- Catalog ---
 
-    async def browse(self, *, category: str | None = None, tag: str | None = None, page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default", recently_played_days: int = 0) -> list[dict]:
+    async def browse(
+        self,
+        *,
+        category: str | None = None,
+        tag: str | None = None,
+        page: int = 1,
+        per_page: int = 24,
+        show_hidden: bool = False,
+        sort: str = "default",
+        recently_played_days: int = 0,
+    ) -> list[dict]:
         query = """
             SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.cover_art_source, c.thumbnail_url, c.manifest_url
             FROM catalog c
@@ -245,7 +257,14 @@ class _CatalogMixin:
         params.extend([per_page, (page - 1) * per_page])
         return await self._fetch_all(query, params)
 
-    async def browse_count(self, *, category: str | None = None, tag: str | None = None, show_hidden: bool = False, recently_played_days: int = 0) -> int:
+    async def browse_count(
+        self,
+        *,
+        category: str | None = None,
+        tag: str | None = None,
+        show_hidden: bool = False,
+        recently_played_days: int = 0,
+    ) -> int:
         query = """
             SELECT COUNT(*) as cnt FROM catalog c
             WHERE c.friendly_token NOT IN (
@@ -284,8 +303,18 @@ class _CatalogMixin:
         row = await self._fetch_one(query, params)
         return row["cnt"] if row else 0
 
-    async def search(self, query_text: str, *, category: str | None = None, tag: str | None = None,
-                     page: int = 1, per_page: int = 24, show_hidden: bool = False, sort: str = "default", recently_played_days: int = 0) -> list[dict]:
+    async def search(
+        self,
+        query_text: str,
+        *,
+        category: str | None = None,
+        tag: str | None = None,
+        page: int = 1,
+        per_page: int = 24,
+        show_hidden: bool = False,
+        sort: str = "default",
+        recently_played_days: int = 0,
+    ) -> list[dict]:
         sql = """
             SELECT c.friendly_token, c.title, c.duration_sec, c.cover_art_path, c.cover_art_source, c.thumbnail_url, c.manifest_url,
                    rank AS relevance
@@ -314,13 +343,24 @@ class _CatalogMixin:
         params.extend(facet_params)
         # Relevance is the natural default for a text query; other sort keys let
         # the user reorder the matched set explicitly.
-        sql += " ORDER BY rank " if (sort or "default") == "default" else _browse_order_clause(sort)
+        sql += (
+            " ORDER BY rank "
+            if (sort or "default") == "default"
+            else _browse_order_clause(sort)
+        )
         sql += " LIMIT ? OFFSET ? "
         params.extend([per_page, (page - 1) * per_page])
         return await self._fetch_all(sql, params)
 
-    async def search_count(self, query_text: str, *, category: str | None = None, tag: str | None = None,
-                           show_hidden: bool = False, recently_played_days: int = 0) -> int:
+    async def search_count(
+        self,
+        query_text: str,
+        *,
+        category: str | None = None,
+        tag: str | None = None,
+        show_hidden: bool = False,
+        recently_played_days: int = 0,
+    ) -> int:
         sql = """
             SELECT COUNT(*) as cnt
             FROM catalog_fts fts
@@ -360,7 +400,9 @@ class _CatalogMixin:
         return await self._fetch_one(sql, [friendly_token])
 
     async def get_item_admin(self, friendly_token: str) -> dict | None:
-        return await self._fetch_one("SELECT * FROM catalog WHERE friendly_token = ?", [friendly_token])
+        return await self._fetch_one(
+            "SELECT * FROM catalog WHERE friendly_token = ?", [friendly_token]
+        )
 
     async def resolve_media(self, media_id: str) -> dict | None:
         """Resolve a now-playing identifier to its catalog row (token + duration).
@@ -376,8 +418,9 @@ class _CatalogMixin:
             [media_id, media_id],
         )
 
-    async def record_play_completion(self, *, friendly_token: str, duration_sec: int | None,
-                                     media_type: str = "cm") -> None:
+    async def record_play_completion(
+        self, *, friendly_token: str, duration_sec: int | None, media_type: str = "cm"
+    ) -> None:
         """Record a genuine play-completion, routing it to the correct hide rule.
 
         Short (<1h) episodes that belong to a mutable (TV-show) playlist are
@@ -449,7 +492,9 @@ class _CatalogMixin:
         )
         return {r["media_id"] for r in rows}
 
-    async def clear_play_state(self, friendly_token: str, *, media_type: str = "cm") -> dict:
+    async def clear_play_state(
+        self, friendly_token: str, *, media_type: str = "cm"
+    ) -> dict:
         """Remove all recently-played hide state for an item (admin test helper).
 
         Deletes both time-boxed ``play_completions`` rows and any
@@ -473,7 +518,10 @@ class _CatalogMixin:
             "DELETE FROM playlist_item_played WHERE media_id = ? AND media_type = ?",
             [friendly_token, media_type],
         )
-        return {"completions": pc["c"] if pc else 0, "playlist_pass": pip["c"] if pip else 0}
+        return {
+            "completions": pc["c"] if pc else 0,
+            "playlist_pass": pip["c"] if pip else 0,
+        }
 
     async def purge_promo_hide_state(self) -> dict:
         """Remove any recently-played hide state recorded for promos/bumpers.
@@ -493,9 +541,16 @@ class _CatalogMixin:
             f"SELECT COUNT(*) AS c FROM playlist_item_played WHERE media_id IN ({sub})",
             sub_params,
         )
-        await self._execute(f"DELETE FROM play_completions WHERE media_id IN ({sub})", sub_params)
-        await self._execute(f"DELETE FROM playlist_item_played WHERE media_id IN ({sub})", sub_params)
-        return {"completions": pc["c"] if pc else 0, "playlist_pass": pip["c"] if pip else 0}
+        await self._execute(
+            f"DELETE FROM play_completions WHERE media_id IN ({sub})", sub_params
+        )
+        await self._execute(
+            f"DELETE FROM playlist_item_played WHERE media_id IN ({sub})", sub_params
+        )
+        return {
+            "completions": pc["c"] if pc else 0,
+            "playlist_pass": pip["c"] if pip else 0,
+        }
 
     async def get_recently_played_debug(self, days: int) -> dict:
         """Snapshot of what the recently-played rules currently hide (admin test).
@@ -524,7 +579,9 @@ class _CatalogMixin:
             "by_playlist_pass": by_playlist_pass,
         }
 
-    async def get_catalog_brief(self, tokens: list[str], manifest_urls: list[str]) -> dict[str, dict]:
+    async def get_catalog_brief(
+        self, tokens: list[str], manifest_urls: list[str]
+    ) -> dict[str, dict]:
         """Return a lookup of catalog metadata keyed by BOTH friendly_token and
         manifest_url, for enriching queue-shadow items that may only carry one.
         """
@@ -606,7 +663,9 @@ class _CatalogMixin:
         """
         return await self._fetch_all(sql, params)
 
-    async def get_tags(self, *, limit: int = 100, show_hidden: bool = False) -> list[dict]:
+    async def get_tags(
+        self, *, limit: int = 100, show_hidden: bool = False
+    ) -> list[dict]:
         """Most-used tags that have at least one catalog item, for facets."""
         sql = """
             SELECT t.id, t.name, COUNT(ct.friendly_token) AS cnt
@@ -628,7 +687,9 @@ class _CatalogMixin:
 
     async def upsert_category(self, name: str) -> int:
         """Insert a category by name (deriving a unique slug) and return its id."""
-        existing = await self._fetch_one("SELECT id FROM categories WHERE name = ?", [name])
+        existing = await self._fetch_one(
+            "SELECT id FROM categories WHERE name = ?", [name]
+        )
         if existing:
             return existing["id"]
         base = _slugify(name)
@@ -651,7 +712,9 @@ class _CatalogMixin:
         await self._db.commit()
         return cursor.lastrowid
 
-    async def set_catalog_categories(self, friendly_token: str, category_ids: list[int]):
+    async def set_catalog_categories(
+        self, friendly_token: str, category_ids: list[int]
+    ):
         """Replace the category memberships for a catalog item."""
         await self._db.execute(
             "DELETE FROM catalog_categories WHERE friendly_token = ?", [friendly_token]
@@ -778,7 +841,15 @@ class _CatalogMixin:
     async def finish_sync_log(self, log_id: int, stats: dict, status: str):
         await self._execute(
             "UPDATE sync_log SET ended_at=?, items_seen=?, items_new=?, items_updated=?, errors=?, status=? WHERE id=?",
-            [datetime.now(UTC).isoformat(), stats["seen"], stats["new"], stats["updated"], stats["errors"], status, log_id],
+            [
+                datetime.now(UTC).isoformat(),
+                stats["seen"],
+                stats["new"],
+                stats["updated"],
+                stats["errors"],
+                status,
+                log_id,
+            ],
         )
 
     async def get_sync_logs(self, limit: int = 10) -> list[dict]:
@@ -788,8 +859,9 @@ class _CatalogMixin:
 
     # --- Generic job runs ---
 
-    async def start_job_run(self, job_name: str, triggered_by: str | None = None,
-                            params: str | None = None) -> int:
+    async def start_job_run(
+        self, job_name: str, triggered_by: str | None = None, params: str | None = None
+    ) -> int:
         cursor = await self._db.execute(
             "INSERT INTO job_runs (job_name, started_at, status, triggered_by, params) "
             "VALUES (?, ?, 'running', ?, ?)",
@@ -806,11 +878,11 @@ class _CatalogMixin:
 
     async def update_job_run_detail(self, run_id: int, detail: str | None):
         """Update only a running job's detail column (used for live progress)."""
-        await self._execute(
-            "UPDATE job_runs SET detail=? WHERE id=?", [detail, run_id]
-        )
+        await self._execute("UPDATE job_runs SET detail=? WHERE id=?", [detail, run_id])
 
-    async def get_job_runs(self, job_name: str | None = None, limit: int = 10) -> list[dict]:
+    async def get_job_runs(
+        self, job_name: str | None = None, limit: int = 10
+    ) -> list[dict]:
         if job_name:
             return await self._fetch_all(
                 "SELECT * FROM job_runs WHERE job_name=? ORDER BY id DESC LIMIT ?",
@@ -855,4 +927,6 @@ class _CatalogMixin:
         return False
 
     async def cleanup_expired_otps(self):
-        await self._execute("DELETE FROM otps WHERE expires_at < datetime('now') OR used=1")
+        await self._execute(
+            "DELETE FROM otps WHERE expires_at < datetime('now') OR used=1"
+        )

{kryten_webqueue-0.32.3 → kryten_webqueue-0.33.1}/kryten_webqueue/catalog/db/_connection.py

@@ -339,7 +339,9 @@ class _DBBase:
         for version, sql in enumerate(MIGRATIONS[1:], start=1):
             if version > current_version:
                 await self._executescript(sql)
-                await self._execute("INSERT INTO _migrations (version) VALUES (?)", [version])
+                await self._execute(
+                    "INSERT INTO _migrations (version) VALUES (?)", [version]
+                )
 
     # --- Low-level helpers ---