kryten-webqueue 0.44.3__tar.gz → 0.44.5__tar.gz

{kryten_webqueue-0.44.3 → kryten_webqueue-0.44.5}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.44.5] - 2026-08-30
+
+### Fixed
+
+- **Queue pricing degrades gracefully when economy is unreachable.** The
+  pay-to-play cost preview (used by `POST /queue/add`, `/queue/playnext`, and
+  `GET /queue/preview`) is proxied through kryten-api-gate to kryten-economy.
+  When economy was down the proxy returned a 5xx and webqueue surfaced an
+  unhandled **HTTP 500**. Those calls now go through `_queue_preview_or_503`,
+  which maps upstream 5xx and transport errors to a clean **HTTP 503**
+  ("Pricing is temporarily unavailable. Please try again in a moment.").
+
+## [0.44.4] - 2026-08-30
+
+### Added
+
+- **Pre-upload video validation.** After download and before uploading to
+  MediaCMS, the fetcher now runs `ffprobe` on the file and rejects it if it has
+  no video stream or zero duration. MediaCMS deletes any upload it can't identify
+  as video (its `media_init` removes the original when `ffprobe` fails), which
+  otherwise showed up as a successful `201` followed by a silently vanished item.
+  A bad download now fails fast with a clear reason instead. If `ffprobe` is
+  unavailable the check is skipped (non-fatal).
+
 ## [0.44.3] - 2026-08-29
 
 ### Fixed

{kryten_webqueue-0.44.3 → kryten_webqueue-0.44.5}/PKG-INFO

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

{kryten_webqueue-0.44.3 → kryten_webqueue-0.44.5}/kryten_webqueue/integrations/ytpipe/downloader.py

@@ -22,6 +22,7 @@ import argparse
 import json
 import os
 import re
+import subprocess
 import sys
 import time
 from pathlib import Path
@@ -3069,6 +3070,57 @@ class MediaDownloaderToMediaCMS:
 
         return results
 
+    def _validate_downloaded_video(self, file_path: str) -> None:
+        """Reject an unreadable download before uploading.
+
+        MediaCMS runs ffprobe on every upload and *deletes* anything it can't
+        identify as video, so a truncated/invalid file would upload with a 201
+        and then silently vanish. Fail here instead, with a clear reason.
+        """
+        if not os.path.exists(file_path) or os.path.getsize(file_path) == 0:
+            raise ValueError(f"downloaded file missing or empty: {file_path}")
+        try:
+            proc = subprocess.run(
+                [
+                    "ffprobe",
+                    "-v",
+                    "error",
+                    "-select_streams",
+                    "v:0",
+                    "-show_entries",
+                    "stream=codec_type:format=duration",
+                    "-of",
+                    "json",
+                    file_path,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+        except (OSError, subprocess.SubprocessError) as e:
+            # ffprobe missing/errored: don't block the upload on our own check.
+            print(f"[WARN] skipping pre-upload validation (ffprobe unavailable): {e}")
+            return
+        if proc.returncode != 0:
+            raise ValueError(
+                f"ffprobe could not read the file: {proc.stderr.strip()[:200]}"
+            )
+        try:
+            meta = json.loads(proc.stdout or "{}")
+        except ValueError:
+            raise ValueError("ffprobe returned unparseable output")
+        has_video = any(
+            s.get("codec_type") == "video" for s in meta.get("streams") or []
+        )
+        try:
+            duration = float((meta.get("format") or {}).get("duration") or 0)
+        except (TypeError, ValueError):
+            duration = 0.0
+        if not has_video or duration <= 0:
+            raise ValueError(
+                f"downloaded file is not a valid video (video_stream={has_video}, duration={duration})"
+            )
+
     def process_video(
         self,
         url: str,
@@ -3132,6 +3184,9 @@ class MediaDownloaderToMediaCMS:
             print(f"Downloaded: {file_path}")
 
         try:
+            # Reject unreadable downloads before upload (MediaCMS deletes files
+            # ffprobe can't parse, which otherwise looks like a vanished upload).
+            self._validate_downloaded_video(file_path)
             # Upload to MediaCMS
             if not playlist_info:
                 print("Uploading to MediaCMS...")

{kryten_webqueue-0.44.3 → kryten_webqueue-0.44.5}/kryten_webqueue/routes/queue.py

@@ -1,3 +1,6 @@
+import logging
+
+import httpx
 from fastapi import APIRouter, Request, Depends, HTTPException
 from datetime import datetime, UTC
 
@@ -6,6 +9,35 @@ from ..queue.ordering import insert_pay_queue, insert_pay_playnext
 
 router = APIRouter(prefix="/queue", tags=["queue"])
 
+logger = logging.getLogger(__name__)
+
+_PRICING_UNAVAILABLE = (
+    "Pricing is temporarily unavailable. Please try again in a moment."
+)
+
+
+async def _queue_preview_or_503(
+    api_gate, *, username: str, duration_sec: int, tier: str
+) -> dict:
+    """Fetch a cost preview, degrading to HTTP 503 when economy is unreachable.
+
+    Pricing is proxied through kryten-api-gate to kryten-economy. If economy is
+    down the proxy returns a 5xx (or the call fails at the transport layer);
+    surface that as a clean 503 instead of an unhandled 500.
+    """
+    try:
+        return await api_gate.queue_preview(
+            username=username, duration_sec=duration_sec, tier=tier
+        )
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code >= 500:
+            logger.warning("queue_preview upstream error: %s", exc)
+            raise HTTPException(503, _PRICING_UNAVAILABLE)
+        raise
+    except httpx.RequestError as exc:
+        logger.warning("queue_preview transport error: %s", exc)
+        raise HTTPException(503, _PRICING_UNAVAILABLE)
+
 
 async def _pre_fire_lock_detail(db) -> str:
     """Build a specific 'pay-to-play closes before [event]' message.
@@ -78,7 +110,8 @@ async def add_to_queue(request: Request, user: dict = Depends(get_current_user))
 
     # Preview cost (api-gate _unwrap strips the success envelope; raise_for_status
     # handles non-2xx, so no success check needed here)
-    preview = await api_gate.queue_preview(
+    preview = await _queue_preview_or_503(
+        api_gate,
         username=user["username"],
         duration_sec=item["duration_sec"],
         tier=tier,
@@ -135,7 +168,8 @@ async def play_next(request: Request, user: dict = Depends(get_current_user)):
 
     # Preview cost (api-gate _unwrap strips the success envelope; raise_for_status
     # handles non-2xx, so no success check needed here)
-    preview = await api_gate.queue_preview(
+    preview = await _queue_preview_or_503(
+        api_gate,
         username=user["username"],
         duration_sec=item["duration_sec"],
         tier=tier,
@@ -187,7 +221,8 @@ async def cost_preview(
     if not item:
         raise HTTPException(404, "Item not found")
 
-    preview = await api_gate.queue_preview(
+    preview = await _queue_preview_or_503(
+        api_gate,
         username=user["username"],
         duration_sec=item["duration_sec"],
         tier=tier,

{kryten_webqueue-0.44.3 → kryten_webqueue-0.44.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryten-webqueue"
-version = "0.44.3"
+version = "0.44.5"
 description = "Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube"
 readme = "README.md"
 license = "MIT"

kryten_webqueue-0.44.5/tests/test_queue_preview_fallback.py

@@ -0,0 +1,68 @@
+"""Graceful degradation when economy pricing is unreachable.
+
+`_queue_preview_or_503` wraps the api-gate cost preview so that an economy /
+api-gate outage surfaces as a clean HTTP 503 instead of an unhandled 500.
+"""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+from fastapi import HTTPException
+
+from kryten_webqueue.routes.queue import _queue_preview_or_503
+
+
+class _FakeApiGate:
+    def __init__(self, exc: Exception | None = None, result: dict | None = None):
+        self._exc = exc
+        self._result = result or {"available": True, "cost_z": 100}
+
+    async def queue_preview(
+        self, *, username: str, duration_sec: int, tier: str
+    ) -> dict:
+        if self._exc is not None:
+            raise self._exc
+        return self._result
+
+
+def _status_error(code: int) -> httpx.HTTPStatusError:
+    request = httpx.Request("POST", "http://api-gate/economy/queue-preview")
+    response = httpx.Response(code, request=request)
+    return httpx.HTTPStatusError("upstream", request=request, response=response)
+
+
+async def test_passthrough_on_success():
+    api = _FakeApiGate(result={"available": True, "cost_z": 250})
+    out = await _queue_preview_or_503(
+        api, username="alice", duration_sec=600, tier="queue"
+    )
+    assert out["cost_z"] == 250
+
+
+@pytest.mark.parametrize("code", [500, 502, 503])
+async def test_upstream_5xx_becomes_503(code: int):
+    api = _FakeApiGate(exc=_status_error(code))
+    with pytest.raises(HTTPException) as excinfo:
+        await _queue_preview_or_503(
+            api, username="alice", duration_sec=600, tier="queue"
+        )
+    assert excinfo.value.status_code == 503
+
+
+async def test_transport_error_becomes_503():
+    request = httpx.Request("POST", "http://api-gate/economy/queue-preview")
+    api = _FakeApiGate(exc=httpx.ConnectError("refused", request=request))
+    with pytest.raises(HTTPException) as excinfo:
+        await _queue_preview_or_503(
+            api, username="alice", duration_sec=600, tier="queue"
+        )
+    assert excinfo.value.status_code == 503
+
+
+async def test_upstream_4xx_propagates():
+    api = _FakeApiGate(exc=_status_error(404))
+    with pytest.raises(httpx.HTTPStatusError):
+        await _queue_preview_or_503(
+            api, username="alice", duration_sec=600, tier="queue"
+        )