kryten-webqueue 0.47.0__tar.gz → 0.48.1__tar.gz

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.48.1] - 2026-09-23
+
+### Fixed
+
+- **Production 500 on `/catalog/browse` in partitioned SQLite mode**: `get_tags()` (facet
+  counts) unconditionally ran the monolith reserved-item exclusion subquery referencing
+  `saved_playlist_items`/`saved_playlists`, tables that live in `queue.sqlite3`, not
+  `catalog.sqlite3`. Every browse/search page load crashed with
+  `sqlite3.OperationalError: no such table: saved_playlist_items` once the site was
+  cut over to `layout="partitioned"`. `get_tags` now accepts `exclude_tokens`/
+  `is_partitioned`, and the `Database` facade resolves reserved/blackout exclusions via
+  the `queue` domain before calling it, matching the existing `browse`/`search` pattern.
+- **Reserved-item exclusion leak in partitioned mode**: `queue.get_reserved_media_ids()`
+  returns raw `media_id` values, which are usually CyTube manifest URLs, not bare
+  `friendly_token`s. `browse`, `browse_count`, `search`, and `search_count` were comparing
+  these raw values directly against `catalog.friendly_token`, so immutable/promo-pool
+  items whose playlist entry stored a manifest URL were **not excluded** from public
+  results. Added `catalog.resolve_friendly_tokens()` to resolve either shape back to
+  `friendly_token`, and all four call sites now use it via a shared
+  `Database._get_reserved_tokens()` helper.
+
+## [0.48.0] - 2026-09-23
+
+### Added
+
+- **PostgreSQL & Chandra-1 Podman Migration Foundations (`postgres-migration`)**:
+  - Added PostgreSQL backend support and configuration in `kryten_webqueue/config.py` with `PostgresConfig` and `DatabaseConfig(backend="sqlite"|"postgres")`.
+  - Added SQLAlchemy 2.0 async engine and session factory builder in `kryten_webqueue/catalog/db/engine.py` (`create_pg_engine`) utilizing `asyncpg` with connection pooling (`pool_size=10`, `max_overflow=20`, `pool_pre_ping=True`).
+  - Added schema DDL `kryten_webqueue/catalog/db/sql/001_initial_schema.sql` defining 40 tables across 5 logical schemas (`catalog`, `queue`, `jobs`, `users`, `tmdb`), English `tsvector` generated search vector, and `pg_trgm` fuzzy trigram matching.
+  - Implemented automated 30-day job run log pruning task (`job_log_prune_job`) in `kryten_webqueue/jobs/tasks.py` and `kryten_webqueue/catalog/db/_jobs_db.py` with strict exemptions for financial, chat, feedback, and audit history.
+  - Implemented one-shot ETL streaming script `kryten_webqueue/migrate_sqlite_to_pg.py` (`kryten-webqueue-migrate-pg`) with batched row streaming, identity sequence synchronization (`setval`), type normalization, and verification reporting.
+  - Added rootful Podman Quadlet specifications (`deploy/podman/webqueue/webqueue.network` and `webqueue-app.container`) and Containerfile for deployment on `chandra-1`.
+  - Added comprehensive operational cutover runbook `docs/postgres-cutover.md`.
+
 ## [0.47.0] - 2026-09-23
 
 ### Added

kryten_webqueue-0.48.1/Containerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential ffmpeg curl \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd --system --create-home --uid 1001 kryten
+
+COPY . /tmp/kryten-webqueue
+
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir /tmp/kryten-webqueue
+
+RUN mkdir -p /etc/kryten-webqueue /var/lib/kryten-webqueue /var/log/kryten-webqueue \
+    && chown -R kryten:kryten /etc/kryten-webqueue /var/lib/kryten-webqueue /var/log/kryten-webqueue
+
+USER kryten
+
+EXPOSE 2010
+
+ENTRYPOINT ["kryten-webqueue"]
+CMD ["--config", "/etc/kryten-webqueue/config.json"]

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.5
 Name: kryten-webqueue
-Version: 0.47.0
+Version: 0.48.1
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.20
 Requires-Dist: apscheduler>=3.10
+Requires-Dist: asyncpg>=0.29.0
 Requires-Dist: fastapi>=0.115
+Requires-Dist: greenlet>=3.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: jinja2>=3.1
 Requires-Dist: msal>=1.28
@@ -21,6 +23,7 @@ Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: python-slugify>=8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.31
+Requires-Dist: sqlalchemy>=2.0.30
 Requires-Dist: uvicorn[standard]>=0.30
 Requires-Dist: websockets>=12.0
 Requires-Dist: yt-dlp>=2024.1

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/config.example.json

@@ -63,13 +63,25 @@
   },
 
   "database": {
+    "backend": "sqlite",
     "layout": "monolith",
     "db_path": "/var/lib/kryten-webqueue/webqueue.db",
     "data_dir": "/var/lib/kryten-webqueue/data",
     "catalog_db_path": null,
     "queue_db_path": null,
     "jobs_db_path": null,
-    "users_db_path": null
+    "users_db_path": null,
+    "postgres": {
+      "host": "host.containers.internal",
+      "port": 5432,
+      "user": "kryten",
+      "dbname": "webqueue",
+      "password_env": "KRYTEN_WEBQUEUE_PG_PASSWORD",
+      "dsn_env": null,
+      "dsn": null,
+      "pool_size": 10,
+      "max_overflow": 20
+    }
   },
   "db_path": "/var/lib/kryten-webqueue/webqueue.db",
 

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/deploy/nginx-queue.conf

@@ -13,8 +13,13 @@ server {
 
     add_header Strict-Transport-Security "max-age=31536000" always;
 
+    # Upstream application backend:
+    # - Local grindhouse service: http://127.0.0.1:2010
+    # - Cross-network Chandra-1 Podman container: http://chandra-1.local:2010
+
     # WebSocket upgrade
     location /ws {
+        # Use http://chandra-1.local:2010 when deployed to Chandra-1 Podman pod
         proxy_pass http://127.0.0.1:2010;
         proxy_http_version 1.1;
         proxy_set_header Upgrade $http_upgrade;
@@ -28,6 +33,7 @@ server {
 
     # API + pages
     location / {
+        # Use http://chandra-1.local:2010 when deployed to Chandra-1 Podman pod
         proxy_pass http://127.0.0.1:2010;
         proxy_http_version 1.1;
         proxy_set_header Connection "";

kryten_webqueue-0.48.1/deploy/podman/webqueue/webqueue-app.container

@@ -0,0 +1,24 @@
+[Unit]
+Description=kryten-webqueue - CyTube Queue Management (FastAPI app)
+After=network-online.target
+
+[Container]
+ContainerName=webqueue-app
+Image=localhost/kryten-webqueue:latest
+Network=podman-webqueue
+PublishPort=2010:2010
+AddHost=host.containers.internal:host-gateway
+
+EnvironmentFile=/etc/kryten/webqueue/webqueue.env
+Volume=/etc/kryten/webqueue/config.json:/etc/kryten-webqueue/config.json:ro,z
+Volume=/var/lib/kryten/media:/var/lib/kryten-webqueue:Z
+Volume=/var/log/kryten/webqueue:/var/log/kryten-webqueue:Z
+
+Exec=uvicorn kryten_webqueue.app:app --host 0.0.0.0 --port 2010
+
+[Service]
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target default.target

kryten_webqueue-0.48.1/deploy/podman/webqueue/webqueue.network

@@ -0,0 +1,3 @@
+[Network]
+NetworkName=podman-webqueue
+Subnet=10.89.30.0/24

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/docs/DATABASE_ARCHITECTURE_PLAN.md

@@ -133,18 +133,29 @@ Upon completion of Part 1, the partitioned domain model directly maps to Postgre
 - `tmdb.*` — Persistent, queryable local TMDB dump index.
 
 ```
+┌─────────────────────────────────────────┐
+│          grindhouse.local Host          │
+│                                         │
+│   ┌─────────────────────────────────┐   │
+│   │           nginx proxy           │   │
+│   │    queue.dropsugar.co (SSL)     │   │
+│   └────────────────┬────────────────┘   │
+└────────────────────┼────────────────────┘
+                     │ LAN Reverse Proxy
+                     │ http://chandra-1.local:2010
+                     ▼
 ┌────────────────────────────────────────────────────────────────────────────────────────┐
 │                                 chandra-1 Host System                                  │
 │                                                                                        │
 │  ┌──────────────────────────────────────────────────────────────────────────────────┐  │
-│  │                            Podman Pod: kryten-webqueue                           │  │
+│  │                     Podman Container: webqueue-app                               │  │
 │  │                                                                                  │  │
-│  │  ┌─────────────────────────────┐           ┌──────────────────────────────────┐  │  │
-│  │  │    kryten-webqueue-app      │           │           nginx proxy            │  │  │
-│  │  │   (FastAPI + uvicorn)       │◄─────────►│     (Reverse Proxy + SSL)        │  │  │
-│  │  │   SQLAlchemy 2.0 (asyncpg)  │           │                                  │  │  │
-│  │  └──────────────┬──────────────┘           └────────────────┬─────────────────┘  │  │
-│  └─────────────────┼───────────────────────────────────────────┼────────────────────┘  │
+│  │  ┌─────────────────────────────┐                                                 │  │
+│  │  │    kryten-webqueue-app      │                                                 │  │
+│  │  │   (FastAPI + uvicorn:2010)  │                                                 │  │
+│  │  │   SQLAlchemy 2.0 (asyncpg)  │                                                 │  │
+│  │  └──────────────┬──────────────┘                                                 │  │
+│  └─────────────────┼───────────────────────────────────────────┬────────────────────┘  │
 │                    │                                           │                       │
 │                    ▼                                           ▼                       │
 │  ┌─────────────────────────────────────┐     ┌──────────────────────────────────────┐  │
@@ -156,6 +167,11 @@ Upon completion of Part 1, the partitioned domain model directly maps to Postgre
 └────────────────────────────────────────────────────────────────────────────────────────┘
 ```
 
+The public hostname `https://queue.dropsugar.co/` terminates TLS via Let's Encrypt Nginx on
+`grindhouse.local`. During the Chandra-1 cutover, the Nginx reverse proxy configuration on
+`grindhouse.local` (`/etc/nginx/sites-available/queue.conf`) is updated to forward HTTP and
+WebSocket traffic across the local network to `http://chandra-1.local:2010`.
+
 ### 2.2 Core Technical Specifications
 
 1. **ORM & Driver**: **SQLAlchemy 2.0 with `asyncpg`** (`create_async_engine`, `async_sessionmaker`, `AsyncSession`).

kryten_webqueue-0.48.1/docs/postgres-cutover.md

@@ -0,0 +1,152 @@
+# PostgreSQL Cutover Runbook: Kryten-WebQueue
+
+**Target Version**: `0.48.0`  
+**Host Target**: `chandra-1` (PostgreSQL 16 + Podman Quadlet)  
+**Source Host**: `grindhouse.local` (pipx systemd / SQLite partitioned data)  
+**Parent Plan**: [DATABASE_ARCHITECTURE_PLAN.md](DATABASE_ARCHITECTURE_PLAN.md)  
+**PRD**: [postgres-migration/PRD-postgres-migration.md](postgres-migration/PRD-postgres-migration.md)  
+
+---
+
+## 1. Pre-Flight Checklist
+
+- [ ] `chandra-1` has PostgreSQL 16+ active and `pg_trgm` extension installed.
+- [ ] Database `webqueue` exists with owner `kryten`.
+- [ ] Schema `001_initial_schema.sql` applied cleanly across `catalog`, `queue`, `jobs`, `users`, `tmdb`.
+- [ ] Privileges granted to `kryten`:
+  ```sql
+  GRANT USAGE, CREATE ON SCHEMA catalog, queue, jobs, users, tmdb TO kryten;
+  GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA catalog, queue, jobs, users, tmdb, public TO kryten;
+  GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA catalog, queue, jobs, users, tmdb, public TO kryten;
+  ALTER DEFAULT PRIVILEGES IN SCHEMA catalog, queue, jobs, users, tmdb GRANT ALL ON TABLES TO kryten;
+  ALTER DEFAULT PRIVILEGES IN SCHEMA catalog, queue, jobs, users, tmdb GRANT ALL ON SEQUENCES TO kryten;
+  ```
+- [ ] Podman image built on `chandra-1`:
+  ```bash
+  sudo podman build -f Containerfile -t localhost/kryten-webqueue:latest .
+  ```
+- [ ] Environment file `/etc/kryten/webqueue/webqueue.env` created on `chandra-1`:
+  ```env
+  KRYTEN_WEBQUEUE_PG_PASSWORD=kryten_secret_password
+  ```
+
+---
+
+## 2. Maintenance Window Cutover (Step-by-Step)
+
+### Step 1: Stop Source Service & Freeze Writes
+On `grindhouse.local`:
+```bash
+sudo systemctl stop kryten-webqueue.service
+sudo systemctl status kryten-webqueue.service --no-pager
+```
+
+### Step 2: Checkpoint SQLite WAL & Create Final Snapshot
+On `grindhouse.local`:
+```bash
+SNAPSHOT_DIR="/var/lib/kryten-webqueue/backups/cutover_$(date +%Y%m%d_%H%M%S)"
+sudo mkdir -p "$SNAPSHOT_DIR"
+
+for db in catalog queue jobs users; do
+  sudo sqlite3 "/var/lib/kryten-webqueue/data/$db.sqlite3" "PRAGMA wal_checkpoint(TRUNCATE);"
+done
+
+sudo cp -av /var/lib/kryten-webqueue/data "$SNAPSHOT_DIR/"
+sudo cp -av /etc/kryten-webqueue/config.json "$SNAPSHOT_DIR/"
+```
+
+### Step 3: Stream SQLite Data to PostgreSQL on Chandra-1
+Run the ETL migration script with `--verify`:
+```bash
+sudo -u kryten /home/kryten/.local/pipx/venvs/kryten-webqueue/bin/python -m kryten_webqueue.migrate_sqlite_to_pg \
+  --data-dir /var/lib/kryten-webqueue/data \
+  --pg-dsn "postgresql://kryten:kryten_secret_password@chandra-1.local:5432/webqueue"
+```
+Verify `postgres_migration_report.json` indicates `"status": "success"` and 0 errors.
+
+### Step 4: Transfer Media & Image Assets to Chandra-1
+Sync cover art images to `/var/lib/kryten/media`:
+```bash
+rsync -avz /var/lib/kryten-webqueue/images/ groberts@chandra-1.local:/var/lib/kryten/media/images/
+```
+
+### Step 5: Start Podman Quadlet on Chandra-1
+On `chandra-1`:
+```bash
+sudo cp deploy/podman/webqueue/webqueue.network /etc/containers/systemd/
+sudo cp deploy/podman/webqueue/webqueue-app.container /etc/containers/systemd/
+sudo systemctl daemon-reload
+sudo systemctl start webqueue-app.service
+sudo systemctl status webqueue-app.service --no-pager
+```
+
+Verify local health inside `chandra-1`:
+```bash
+curl -I http://127.0.0.1:2010/auth/login
+curl -s http://127.0.0.1:2010/queue/next-schedule
+```
+
+### Step 6: Update Grindhouse Nginx Reverse Proxy Across Network
+The public website `https://queue.dropsugar.co/` terminates SSL via Let's Encrypt Nginx on `grindhouse.local`. Update its upstream to proxy across the LAN to `chandra-1.local:2010`.
+
+On `grindhouse.local`:
+1. Edit `/etc/nginx/sites-available/queue.conf`:
+```nginx
+    # WebSocket upgrade
+    location /ws {
+        proxy_pass http://chandra-1.local:2010;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 86400;
+    }
+
+    # API + pages
+    location / {
+        proxy_pass http://chandra-1.local:2010;
+        proxy_http_version 1.1;
+        proxy_set_header Connection "";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+```
+
+2. Test and reload Nginx:
+```bash
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+### Step 7: Public Smoke Testing & Verification
+Test public endpoints through the reverse proxy:
+```bash
+curl -I https://queue.dropsugar.co/auth/login
+curl -s https://queue.dropsugar.co/queue/next-schedule
+```
+Monitor logs on `chandra-1`:
+```bash
+sudo journalctl -u webqueue-app.service -f
+```
+
+---
+
+## 3. Rollback & Forward Repair Policy
+
+- **Pre-Cutover Failure**: If ETL validation fails, container startup fails on `chandra-1`, or initial smoke tests fail before Nginx is updated:
+  1. Do not update or revert Nginx on `grindhouse.local` (`proxy_pass http://127.0.0.1:2010;`).
+  2. Restart `kryten-webqueue.service` on `grindhouse.local`:
+     ```bash
+     sudo systemctl start kryten-webqueue.service
+     ```
+  3. The SQLite databases remain untouched and consistent.
+- **Traffic Rollback (if Nginx was already switched but app has issues)**:
+  1. Revert `/etc/nginx/sites-available/queue.conf` on `grindhouse.local` to point back to `http://127.0.0.1:2010`.
+  2. Reload Nginx: `sudo nginx -t && sudo systemctl reload nginx`.
+  3. Start `kryten-webqueue.service` on `grindhouse.local`.
+- **Post-Cutover Forward Repair**: Once production traffic is accepted by PostgreSQL (user logins, new spend requests, play completions), recovery is a **forward repair in PostgreSQL**. The retained SQLite snapshot is preserved read-only for forensics.

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/docs/postgres-migration/PRD-postgres-migration.md

@@ -28,6 +28,9 @@ The following decisions are fixed for this sprint:
 - One PostgreSQL database named `webqueue` owns all five schemas. `tmdb` is a schema, not a
   separate database, so catalog enrichment can use relational queries when needed.
 - The application runs as a rootful Podman Quadlet service on `chandra-1`.
+- Public traffic on `https://queue.dropsugar.co/` terminates TLS at Nginx on `grindhouse.local`.
+  During cutover, Nginx on `grindhouse.local` (`/etc/nginx/sites-available/queue.conf`) is updated
+  to reverse-proxy HTTP and WebSocket (`/ws`) traffic across the local network to `http://chandra-1.local:2010`.
 - PostgreSQL is host-managed on `chandra-1`. The rootful application container connects through
   an explicitly configured host-gateway address; it must not use `localhost`.
 - The migration uses a maintenance window and a forward-fix rollback policy. There is no

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/docs/postgres-migration/SPEC-Sortie-6-tests-cutover-release.md

@@ -66,12 +66,19 @@ python -m kryten_webqueue.migrate_sqlite_to_pg --data-dir /path/to/sqlite/data -
 # 5. Grant runtime/pruner roles only after verification, then start the rootful Quadlet.
 sudo systemctl start webqueue-app.service
 
-# 6. Verify health and smoke test browse/search/queue/OTP/device-key/job-log paths.
+# 6. Update Nginx reverse proxy on grindhouse.local to forward across the LAN:
+#    In /etc/nginx/sites-available/queue.conf:
+#    proxy_pass http://chandra-1.local:2010; (for /ws and /)
+#    sudo nginx -t && sudo systemctl reload nginx
+
+# 7. Verify health and smoke test public HTTPS and WebSocket paths:
+curl -f https://queue.dropsugar.co/auth/login
 curl -f http://127.0.0.1:2010/api/public/v1/state
 ```
 
 If a gate fails before PostgreSQL receives production writes, restart the unchanged SQLite
-service. Once PostgreSQL accepts a write, recovery is a forward repair using request identifiers
+service and revert the Nginx proxy_pass on grindhouse.local back to http://127.0.0.1:2010.
+Once PostgreSQL accepts a write, recovery is a forward repair using request identifiers
 and audit records; the retained SQLite snapshot is not an automatic rollback target.
 
 ## 4. Implementation Plan

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/kryten_webqueue/app.py

@@ -111,6 +111,7 @@ async def lifespan(app: FastAPI):
         motd_posters_job,
         tmdb_index_refresh_job,
         tmdb_coverage_report_job,
+        job_log_prune_job,
         CATALOG_ENRICH_SCHEMA,
         CATALOG_BLACKOUT_SCHEMA,
         DEVICE_KEY_BAN_RECONCILE_SCHEMA,
@@ -121,6 +122,7 @@ async def lifespan(app: FastAPI):
         MOTD_POSTERS_SCHEMA,
         TMDB_INDEX_REFRESH_SCHEMA,
         TMDB_COVERAGE_REPORT_SCHEMA,
+        JOB_LOG_PRUNE_SCHEMA,
     )
 
     job_manager.register(
@@ -168,6 +170,12 @@ async def lifespan(app: FastAPI):
         label="MOTD Posters (weekend poster grid)",
         schema=MOTD_POSTERS_SCHEMA,
     )
+    job_manager.register(
+        "job_log_prune",
+        job_log_prune_job,
+        label="Job Run Log Pruner (30-day retention)",
+        schema=JOB_LOG_PRUNE_SCHEMA,
+    )
     from .jobs.motd_publish import motd_publish_job, MOTD_PUBLISH_SCHEMA
 
     job_manager.register(

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/kryten_webqueue/catalog/db/__init__.py

@@ -107,17 +107,17 @@ _DOMAIN_METHOD_MAP: dict[str, str] = {
     "get_job_schedule": "jobs",
     "upsert_job_schedule": "jobs",
     "delete_job_schedule": "jobs",
-    "fetch_queue_add": "jobs",
-    "fetch_queue_get": "jobs",
-    "fetch_queue_update": "jobs",
-    "fetch_queue_delete": "jobs",
-    "fetch_queue_list": "jobs",
-    "fetch_queue_count": "jobs",
-    "fetch_queue_get_next_pending": "jobs",
-    "fetch_queue_mark_started": "jobs",
-    "fetch_queue_mark_finished": "jobs",
-    "fetch_queue_requeue": "jobs",
-    "fetch_queue_cleanup": "jobs",
+    "prune_job_run_logs": "jobs",
+    "enqueue_fetch": "jobs",
+    "claim_next_fetch_item": "jobs",
+    "finish_fetch_item": "jobs",
+    "requeue_fetch_item": "jobs",
+    "requeue_fetch_item_for_retry": "jobs",
+    "reset_running_fetch_items": "jobs",
+    "get_fetch_queue": "jobs",
+    "count_fetch_queue": "jobs",
+    "count_fetch_queue_pending": "jobs",
+    "delete_fetch_queue_item": "jobs",
     # users
     "watchlist_add": "users",
     "watchlist_remove": "users",
@@ -182,6 +182,7 @@ _DOMAIN_METHOD_MAP: dict[str, str] = {
     "get_item_edit_history": "catalog",
     "get_items_by_tokens": "catalog",
     "get_hidden_category_and_tag_tokens": "catalog",
+    "resolve_friendly_tokens": "catalog",
     "get_people": "catalog",
     "get_studios": "catalog",
     "upsert_person": "catalog",
@@ -303,10 +304,22 @@ class Database(
         except AttributeError:
             layout = "monolith"
 
-        if layout == "partitioned" and name in _DOMAIN_METHOD_MAP:
-            domain_name = _DOMAIN_METHOD_MAP[name]
-            domain_obj = object.__getattribute__(self, domain_name)
-            return getattr(domain_obj, name)
+        if layout == "partitioned":
+            if name in Database.__dict__ or name.startswith("_"):
+                return object.__getattribute__(self, name)
+
+            if name in _DOMAIN_METHOD_MAP:
+                domain_name = _DOMAIN_METHOD_MAP[name]
+                domain_obj = object.__getattribute__(self, domain_name)
+                return getattr(domain_obj, name)
+
+            for domain_name in ("jobs", "queue", "users", "catalog"):
+                try:
+                    domain_obj = object.__getattribute__(self, domain_name)
+                    if hasattr(domain_obj, name) and not hasattr(_DBBase, name):
+                        return getattr(domain_obj, name)
+                except AttributeError:
+                    pass
 
         return object.__getattribute__(self, name)
 
@@ -321,6 +334,16 @@ class Database(
 
     # --- Decoupled Cross-Domain Orchestrations ---
 
+    async def _get_reserved_tokens(self) -> set[str]:
+        """Reserved (immutable/promo) media_ids resolved to friendly_tokens.
+
+        queue.db stores media_id as either a bare token or a manifest URL, so
+        the raw values must be resolved through catalog.db before comparing
+        against friendly_token.
+        """
+        raw = await self.queue.get_reserved_media_ids()
+        return await self.catalog.resolve_friendly_tokens(raw)
+
     async def browse(
         self,
         *,
@@ -345,7 +368,7 @@ class Database(
                     recently_played_days
                 )
                 exclude_set.update(hidden)
-            reserved = await self.queue.get_reserved_media_ids()
+            reserved = await self._get_reserved_tokens()
             exclude_set.update(reserved)
             blackouts = await self.queue.get_active_blackout_tokens()
             if not show_hidden:
@@ -413,7 +436,7 @@ class Database(
                     recently_played_days
                 )
                 exclude_set.update(hidden)
-            reserved = await self.queue.get_reserved_media_ids()
+            reserved = await self._get_reserved_tokens()
             exclude_set.update(reserved)
             if not show_hidden:
                 blackouts = await self.queue.get_active_blackout_tokens()
@@ -471,7 +494,7 @@ class Database(
                     recently_played_days
                 )
                 exclude_set.update(hidden)
-            reserved = await self.queue.get_reserved_media_ids()
+            reserved = await self._get_reserved_tokens()
             exclude_set.update(reserved)
             blackouts = await self.queue.get_active_blackout_tokens()
             if not show_hidden:
@@ -542,7 +565,7 @@ class Database(
                     recently_played_days
                 )
                 exclude_set.update(hidden)
-            reserved = await self.queue.get_reserved_media_ids()
+            reserved = await self._get_reserved_tokens()
             exclude_set.update(reserved)
             if not show_hidden:
                 blackouts = await self.queue.get_active_blackout_tokens()
@@ -600,6 +623,38 @@ class Database(
             self, username, page=page, per_page=per_page
         )
 
+    async def get_tags(
+        self,
+        *,
+        limit: int = 100,
+        show_hidden: bool = False,
+        min_duration_sec: int = 0,
+        max_duration_sec: int | None = None,
+        **kwargs: Any,
+    ) -> list[dict]:
+        if self._layout == "partitioned":
+            exclude_set: set[str] = await self._get_reserved_tokens()
+            if not show_hidden:
+                blackouts = await self.queue.get_active_blackout_tokens()
+                exclude_set.update(blackouts)
+            return await self.catalog.get_tags(
+                limit=limit,
+                show_hidden=show_hidden,
+                min_duration_sec=min_duration_sec,
+                max_duration_sec=max_duration_sec,
+                exclude_tokens=exclude_set,
+                is_partitioned=True,
+            )
+
+        return await _CatalogMixin.get_tags(
+            self,
+            limit=limit,
+            show_hidden=show_hidden,
+            min_duration_sec=min_duration_sec,
+            max_duration_sec=max_duration_sec,
+            is_partitioned=False,
+        )
+
     async def get_item(self, friendly_token: str) -> dict | None:
         if self._layout == "partitioned":
             item = await self.catalog.get_item(friendly_token, is_partitioned=True)

{kryten_webqueue-0.47.0 → kryten_webqueue-0.48.1}/kryten_webqueue/catalog/db/_catalog.py

@@ -916,6 +916,8 @@ class _CatalogMixin:
         show_hidden: bool = False,
         min_duration_sec: int = 0,
         max_duration_sec: int | None = None,
+        exclude_tokens: set[str] | list[str] | None = None,
+        is_partitioned: bool = False,
     ) -> list[dict]:
         """Most-used tags that have at least one catalog item, for facets.
 
@@ -929,16 +931,25 @@ class _CatalogMixin:
             WHERE 1=1
         """
         params: list = []
-        resv_sql, resv_params = _reserved_exclusion("c")
-        sql += resv_sql
-        params.extend(resv_params)
+        if not is_partitioned:
+            resv_sql, resv_params = _reserved_exclusion("c")
+            sql += resv_sql
+            params.extend(resv_params)
+            if not show_hidden:
+                bo_sql, bo_params = _blackout_exclusion("c")
+                sql += bo_sql
+                params.extend(bo_params)
         if not show_hidden:
-            bo_sql, bo_params = _blackout_exclusion("c")
-            sql += bo_sql
-            params.extend(bo_params)
             ph = ",".join("?" * len(HIDDEN_TAG_NAMES))
             sql += f" AND t.name NOT IN ({ph})"
             params.extend(HIDDEN_TAG_NAMES)
+        if exclude_tokens:
+            tokens_list = [t for t in exclude_tokens if t]
+            for i in range(0, len(tokens_list), 500):
+                chunk = tokens_list[i : i + 500]
+                ph = ",".join("?" * len(chunk))
+                sql += f" AND c.friendly_token NOT IN ({ph}) "
+                params.extend(chunk)
         if min_duration_sec > 0 or max_duration_sec is not None:
             dur_sql, dur_params = _duration_range_filter(
                 "c", min_duration_sec or None, max_duration_sec
@@ -1331,6 +1342,30 @@ class _CatalogMixin:
     async def delete_job_schedule(self, job_name: str) -> None:
         await self._execute("DELETE FROM job_schedules WHERE job_name=?", [job_name])
 
+    async def prune_job_run_logs(
+        self, retention_days: int = 30, batch_size: int = 5000
+    ) -> int:
+        total_deleted = 0
+        cutoff = f"-{int(retention_days)} days"
+        while True:
+            cursor = await self._db.execute(
+                """
+                DELETE FROM job_run_logs
+                WHERE id IN (
+                    SELECT id FROM job_run_logs
+                    WHERE logged_at < datetime('now', ?)
+                    LIMIT ?
+                )
+                """,
+                [cutoff, batch_size],
+            )
+            await self._db.commit()
+            count = cursor.rowcount or 0
+            total_deleted += count
+            if count < batch_size:
+                break
+        return total_deleted
+
     # --- OTP ---
 
     async def store_otp(self, username: str, code: str, expires_at: str):