kryten-webqueue 0.1.1__py3-none-any.whl

kryten_webqueue/catalog/sync.py

@@ -0,0 +1,96 @@
+import httpx
+import logging
+from datetime import datetime, UTC
+
+logger = logging.getLogger(__name__)
+
+
+class CatalogSync:
+    """Synchronizes catalog data from MediaCMS."""
+
+    def __init__(self, *, mediacms_url: str, mediacms_token: str, db):
+        self._url = mediacms_url.rstrip("/")
+        self._token = mediacms_token
+        self._db = db
+        self._client = httpx.AsyncClient(
+            headers={"Authorization": f"Token {mediacms_token}"},
+            timeout=30.0,
+        )
+
+    async def close(self):
+        await self._client.aclose()
+
+    async def sync(self):
+        """Full catalog sync from MediaCMS API."""
+        log_id = await self._db.start_sync_log()
+        stats = {"seen": 0, "new": 0, "updated": 0, "errors": 0}
+
+        try:
+            page = 1
+            while True:
+                resp = await self._client.get(
+                    f"{self._url}/api/v1/media",
+                    params={"page": page, "page_size": 50},
+                )
+                if resp.status_code != 200:
+                    logger.error(f"MediaCMS API returned {resp.status_code}")
+                    stats["errors"] += 1
+                    break
+
+                data = resp.json()
+                results = data if isinstance(data, list) else data.get("results", [])
+
+                if not results:
+                    break
+
+                for media in results:
+                    stats["seen"] += 1
+                    try:
+                        await self._process_item(media, stats)
+                    except Exception as e:
+                        logger.warning(f"Error processing {media.get('friendly_token')}: {e}")
+                        stats["errors"] += 1
+
+                # Check for next page
+                if isinstance(data, dict) and not data.get("next"):
+                    break
+                page += 1
+
+            await self._db.finish_sync_log(log_id, stats, "completed")
+            logger.info(f"Catalog sync: {stats}")
+        except Exception as e:
+            logger.error(f"Catalog sync failed: {e}")
+            stats["errors"] += 1
+            await self._db.finish_sync_log(log_id, stats, "error")
+
+    async def _process_item(self, media: dict, stats: dict):
+        token = media.get("friendly_token")
+        if not token:
+            return
+
+        now = datetime.now(UTC).isoformat()
+        row = {
+            "friendly_token": token,
+            "title": media.get("title", "Untitled"),
+            "description": media.get("description", ""),
+            "duration_sec": media.get("duration") or 0,
+            "manifest_url": self._build_manifest_url(media),
+            "thumbnail_url": media.get("thumbnail_url", ""),
+            "synced_at": now,
+        }
+
+        existing = await self._db.get_item_admin(token)
+        if existing:
+            await self._db.update_catalog(token, row)
+            stats["updated"] += 1
+        else:
+            await self._db.insert_catalog(row)
+            stats["new"] += 1
+
+    def _build_manifest_url(self, media: dict) -> str:
+        hls_file = media.get("hls_file")
+        if hls_file:
+            return hls_file if hls_file.startswith("http") else f"{self._url}{hls_file}"
+        # Fallback to original URL
+        original = media.get("original_media_url", "")
+        return original if original.startswith("http") else f"{self._url}{original}"

kryten_webqueue/config.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from pydantic import BaseModel
+import json
+
+
+class Config(BaseModel):
+    """Application configuration loaded from JSON file."""
+
+    # Server
+    channel: str = "Q_A"
+    host: str = "0.0.0.0"
+    port: int = 2010
+    secret_key: str
+    session_ttl_hours: int = 24
+
+    # API Gate
+    api_gate_url: str = "http://127.0.0.1:24444"
+    api_gate_token: str
+
+    # MediaCMS
+    mediacms_url: str = "https://www.dropsugar.com"
+    mediacms_token: str
+
+    # Cover art APIs
+    tmdb_api_key: str = ""
+    omdb_api_key: str = ""
+
+    # Database
+    db_path: str = "/var/lib/kryten-webqueue/webqueue.db"
+
+    # Images
+    image_dir: str = "/var/lib/kryten-webqueue/images"
+    placeholder_dir: str = "/var/lib/kryten-webqueue/images/placeholders"
+
+    # Scheduling
+    catalog_sync_interval_hours: int = 4
+    pre_fire_lock_minutes_default: int = 15
+    state_poll_interval_sec: float = 3.0
+
+    # Monitoring
+    prometheus_port: int = 28292
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "Config":
+        with open(path) as f:
+            return cls(**json.load(f))

kryten_webqueue/playlists/fire.py

@@ -0,0 +1,71 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, UTC
+
+from ..queue.ordering import refund_item
+
+logger = logging.getLogger(__name__)
+
+_queue_lock = asyncio.Lock()
+
+
+async def fire_schedule(*, schedule_id: int, api_gate, db, shadow, ws_manager):
+    """Fire a scheduled playlist: clear queue, refund displaced pay items, load playlist."""
+    async with _queue_lock:
+        schedule = await db.get_schedule(schedule_id)
+        if not schedule:
+            logger.error(f"Schedule {schedule_id} not found")
+            return
+
+        playlist_id = schedule["playlist_id"]
+        playlist = await db.get_saved_playlist(playlist_id)
+        if not playlist:
+            logger.error(f"Playlist {playlist_id} not found for schedule {schedule_id}")
+            return
+
+        # Refund all pay items currently in queue
+        pay_items = await db.get_pay_items()
+        for item in pay_items:
+            await refund_item(api_gate=api_gate, db=db, uid=item["uid"], reason="schedule_displaced")
+
+        # Clear the CyTube playlist
+        await api_gate.playlist_clear()
+
+        # Load scheduled playlist items
+        items = await db.get_saved_playlist_items(playlist_id)
+        total_duration = 0
+        for item in items:
+            try:
+                await api_gate.playlist_add(
+                    media_type=item["media_type"],
+                    media_id=item["media_id"],
+                    position="end",
+                )
+                total_duration += item.get("duration_sec", 0) or 0
+            except Exception as e:
+                logger.warning(f"Schedule fire: failed to add {item['media_id']}: {e}")
+
+        # Update active schedule
+        now = datetime.now(UTC)
+        await db.set_active_schedule(
+            schedule_id=schedule_id,
+            playlist_id=playlist_id,
+            is_immutable=playlist.get("is_immutable", False),
+            started_at=now.isoformat(),
+            estimated_end_at=(now + timedelta(seconds=total_duration)).isoformat(),
+        )
+
+        # Mark schedule as fired
+        await db.mark_schedule_fired(schedule_id, now.isoformat())
+
+        # Notify WS clients
+        await ws_manager.broadcast({
+            "type": "schedule_fired",
+            "data": {
+                "schedule_id": schedule_id,
+                "playlist_name": playlist["name"],
+                "is_immutable": playlist.get("is_immutable", False),
+            },
+        })
+
+        logger.info(f"Schedule {schedule_id} fired: playlist '{playlist['name']}' ({len(items)} items)")

kryten_webqueue/playlists/importer.py

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

kryten_webqueue/playlists/scheduler.py

@@ -0,0 +1,72 @@
+import logging
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, UTC
+
+from .fire import fire_schedule
+
+logger = logging.getLogger(__name__)
+
+
+class PlaylistScheduler:
+    """APScheduler-based scheduler for playlist fire events."""
+
+    def __init__(self, *, db, api_gate, shadow, ws_manager):
+        self._db = db
+        self._api_gate = api_gate
+        self._shadow = shadow
+        self._ws_manager = ws_manager
+        self._scheduler = AsyncIOScheduler()
+
+    async def start(self):
+        """Start scheduler and load all pending schedules."""
+        self._scheduler.start()
+        await self._load_schedules()
+        logger.info("PlaylistScheduler started")
+
+    async def stop(self):
+        self._scheduler.shutdown(wait=False)
+        logger.info("PlaylistScheduler stopped")
+
+    async def _load_schedules(self):
+        """Load active schedules from DB and register jobs."""
+        schedules = await self._db.get_schedules()
+        now = datetime.now(UTC)
+        for sched in schedules:
+            if not sched.get("is_active"):
+                continue
+            fire_at_str = sched["fire_at"]
+            fire_at = datetime.fromisoformat(fire_at_str)
+            if fire_at <= now:
+                continue
+            self._add_job(sched["id"], fire_at)
+
+    def _add_job(self, schedule_id: int, fire_at: datetime):
+        job_id = f"schedule_{schedule_id}"
+        self._scheduler.add_job(
+            self._fire,
+            trigger=DateTrigger(run_date=fire_at),
+            id=job_id,
+            replace_existing=True,
+            kwargs={"schedule_id": schedule_id},
+        )
+        logger.info(f"Scheduled job {job_id} for {fire_at}")
+
+    async def _fire(self, schedule_id: int):
+        await fire_schedule(
+            schedule_id=schedule_id,
+            api_gate=self._api_gate,
+            db=self._db,
+            shadow=self._shadow,
+            ws_manager=self._ws_manager,
+        )
+
+    async def add_schedule(self, schedule_id: int, fire_at: datetime):
+        self._add_job(schedule_id, fire_at)
+
+    async def remove_schedule(self, schedule_id: int):
+        job_id = f"schedule_{schedule_id}"
+        try:
+            self._scheduler.remove_job(job_id)
+        except Exception:
+            pass

kryten_webqueue/queue/ordering.py

@@ -0,0 +1,186 @@
+import asyncio
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Module-level lock for queue ordering
+_queue_lock = asyncio.Lock()
+
+
+async def insert_pay_queue(
+    *,
+    api_gate,
+    shadow,
+    db,
+    username: str,
+    media_type: str,
+    media_id: str,
+    title: str,
+    duration_sec: int,
+    tier: str,
+    z_cost: int,
+) -> dict:
+    """Insert a paid item at the end of the pay-queue section (FIFO)."""
+    async with _queue_lock:
+        request_id = str(uuid.uuid4())
+
+        # Spend currency
+        spend_result = await api_gate.queue_spend(
+            username=username,
+            duration_sec=duration_sec,
+            tier=tier,
+            request_id=request_id,
+        )
+        if not spend_result.get("success"):
+            return {"success": False, "error": spend_result.get("error", "Spend failed")}
+
+        # Find position: after last pay item, or prepend if none
+        last_pay_uid = await db.get_last_pay_uid()
+        position = "end" if not last_pay_uid else str(last_pay_uid)
+
+        # Add to CyTube playlist
+        add_result = await api_gate.playlist_add(
+            media_type=media_type,
+            media_id=media_id,
+            position=position,
+        )
+        if not add_result.get("success"):
+            # Refund on failure
+            await api_gate.queue_refund(username=username, request_id=request_id, reason="add_failed")
+            return {"success": False, "error": "Failed to add to playlist"}
+
+        uid = add_result["uid"]
+
+        # Move after last pay UID if needed
+        if last_pay_uid:
+            await api_gate.playlist_move(uid, last_pay_uid)
+
+        # Record spend
+        await db.save_spend_request(
+            request_id, username=username, uid=uid,
+            friendly_token=media_id if media_type == "cm" else None,
+            tier=tier, z_cost=z_cost,
+        )
+
+        # Update local shadow
+        item = {
+            "uid": uid,
+            "title": title,
+            "media_type": media_type,
+            "media_id": media_id,
+            "duration_sec": duration_sec,
+            "is_pay": True,
+            "paid_by": username,
+            "tier": tier,
+            "z_cost": z_cost,
+            "schedule_id": None,
+        }
+        # Position after last pay
+        if last_pay_uid:
+            pos = await db.get_shadow_position_after(last_pay_uid)
+        else:
+            pos = len(shadow.items)
+        await shadow.insert_at(item, pos)
+
+        # Queue history
+        await db.add_queue_history(
+            username=username, friendly_token=media_id if media_type == "cm" else None,
+            title=title, tier=tier, z_cost=z_cost,
+        )
+
+        return {"success": True, "uid": uid, "request_id": request_id}
+
+
+async def insert_pay_playnext(
+    *,
+    api_gate,
+    shadow,
+    db,
+    username: str,
+    media_type: str,
+    media_id: str,
+    title: str,
+    duration_sec: int,
+    tier: str,
+    z_cost: int,
+) -> dict:
+    """Insert a paid item at position 0 (play next)."""
+    async with _queue_lock:
+        request_id = str(uuid.uuid4())
+
+        # Spend currency
+        spend_result = await api_gate.queue_spend(
+            username=username,
+            duration_sec=duration_sec,
+            tier=tier,
+            request_id=request_id,
+        )
+        if not spend_result.get("success"):
+            return {"success": False, "error": spend_result.get("error", "Spend failed")}
+
+        # Add to CyTube playlist at prepend position
+        add_result = await api_gate.playlist_add(
+            media_type=media_type,
+            media_id=media_id,
+            position="end",
+        )
+        if not add_result.get("success"):
+            await api_gate.queue_refund(username=username, request_id=request_id, reason="add_failed")
+            return {"success": False, "error": "Failed to add to playlist"}
+
+        uid = add_result["uid"]
+
+        # Move to front
+        await api_gate.playlist_move(uid, "prepend")
+
+        # Record spend
+        await db.save_spend_request(
+            request_id, username=username, uid=uid,
+            friendly_token=media_id if media_type == "cm" else None,
+            tier=tier, z_cost=z_cost,
+        )
+
+        # Update local shadow at position 0
+        item = {
+            "uid": uid,
+            "title": title,
+            "media_type": media_type,
+            "media_id": media_id,
+            "duration_sec": duration_sec,
+            "is_pay": True,
+            "paid_by": username,
+            "tier": tier,
+            "z_cost": z_cost,
+            "schedule_id": None,
+        }
+        await shadow.insert_at(item, 0)
+
+        await db.add_queue_history(
+            username=username, friendly_token=media_id if media_type == "cm" else None,
+            title=title, tier=tier, z_cost=z_cost,
+        )
+
+        return {"success": True, "uid": uid, "request_id": request_id}
+
+
+async def refund_item(*, api_gate, db, uid: int, reason: str) -> bool:
+    """Refund a paid queue item."""
+    request_id = await db.get_request_id_for_uid(uid)
+    if not request_id:
+        return False
+
+    # Look up the spend to find username
+    row = await db._fetch_one("SELECT username FROM spend_requests WHERE request_id=?", [request_id])
+    if not row:
+        return False
+
+    result = await api_gate.queue_refund(
+        username=row["username"],
+        request_id=request_id,
+        reason=reason,
+    )
+    if result.get("success"):
+        await db.mark_spend_refunded(request_id)
+        return True
+    return False

kryten_webqueue/queue/poller.py

@@ -0,0 +1,43 @@
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class StatePoller:
+    """Polls api-gate at a fixed interval to keep QueueShadow in sync."""
+
+    def __init__(self, *, api_gate, shadow, ws_manager, interval: float = 3.0):
+        self._api_gate = api_gate
+        self._shadow = shadow
+        self._ws_manager = ws_manager
+        self._interval = interval
+        self._task: asyncio.Task | None = None
+
+    async def start(self):
+        self._task = asyncio.create_task(self._loop())
+        logger.info(f"StatePoller started (interval={self._interval}s)")
+
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            logger.info("StatePoller stopped")
+
+    async def _loop(self):
+        while True:
+            try:
+                playlist = await self._api_gate.get_playlist()
+                now_playing = await self._api_gate.get_now_playing()
+                await self._shadow.apply_poll_result(playlist, now_playing)
+                # Broadcast updated state
+                state = self._shadow.get_queue_state()
+                await self._ws_manager.broadcast({"type": "queue_state", "data": state})
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning(f"Poll error: {e}")
+            await asyncio.sleep(self._interval)