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

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

@@ -5,6 +5,12 @@ 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.2] — 2026-07-29
+
+### Added
+
+- **Per-user submission quota on feedback and title suggestions.** Each user may now submit at most **2 per day and 6 per week** for feedback *and* (independently) for suggestions. Exceeding either tier returns `429` with a message pointing at the day/week limit. Implemented as a new `QuotaLimiter` (multi-tier sliding window) wired into the two submit endpoints, in addition to the existing short-burst throttle. Search/resolve requests are unaffected.
+
 ## [0.33.1] — 2026-07-29
 
 ### Changed

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

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

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

@@ -22,7 +22,7 @@ from .queue.presence import PresenceRefundMonitor
 from .promos.director import PromoDirector
 from .ws.manager import WebSocketManager
 from .playlists.scheduler import PlaylistScheduler
-from .auth.rate_limit import RateLimiter
+from .auth.rate_limit import QuotaLimiter, RateLimiter
 
 from .routes.auth import router as auth_router
 from .routes.catalog import router as catalog_router
@@ -196,6 +196,11 @@ async def lifespan(app: FastAPI):
     # feedback/suggestion endpoints (per-user, namespaced keys).
     app.state.rate_limiter = RateLimiter()
     app.state.feedback_rate_limiter = RateLimiter(max_requests=12, window_seconds=300)
+    # Hard per-user submission quota for feedback and suggestions: 2/day, 6/week
+    # (namespaced keys, checked in addition to the short-burst limiter above).
+    app.state.feedback_quota_limiter = QuotaLimiter(
+        [("day", 2, 86_400), ("week", 6, 604_800)]
+    )
 
     # Playlist scheduler
     scheduler = PlaylistScheduler(

kryten_webqueue-0.33.2/kryten_webqueue/auth/rate_limit.py

@@ -0,0 +1,62 @@
+import time
+from collections import defaultdict, deque
+
+
+class RateLimiter:
+    """Sliding-window rate limiter for OTP requests."""
+
+    def __init__(self, max_requests: int = 3, window_seconds: int = 300):
+        self._max = max_requests
+        self._window = window_seconds
+        self._requests: dict[str, deque] = defaultdict(deque)
+
+    def is_allowed(self, key: str) -> bool:
+        now = time.time()
+        window = self._requests[key]
+        # Remove expired entries
+        while window and window[0] < now - self._window:
+            window.popleft()
+        if len(window) >= self._max:
+            return False
+        window.append(now)
+        return True
+
+    def remaining(self, key: str) -> int:
+        now = time.time()
+        window = self._requests[key]
+        while window and window[0] < now - self._window:
+            window.popleft()
+        return max(0, self._max - len(window))
+
+
+class QuotaLimiter:
+    """Sliding-window limiter that enforces several named tiers at once.
+
+    Each tier is ``(label, max_requests, window_seconds)``. An action is only
+    permitted when *every* tier still has room; a permitted action is recorded
+    against all tiers atomically. Used for hard per-user submission quotas
+    (e.g. 2/day and 6/week) rather than short-burst throttling.
+    """
+
+    def __init__(self, tiers: list[tuple[str, int, int]]):
+        if not tiers:
+            raise ValueError("QuotaLimiter requires at least one tier")
+        self._tiers = list(tiers)
+        self._max_window = max(window for _, _, window in self._tiers)
+        self._events: dict[str, deque] = defaultdict(deque)
+
+    def check(self, key: str) -> str | None:
+        """Return the label of the first exhausted tier, or ``None`` if allowed.
+
+        When allowed the action is recorded; when blocked nothing is recorded.
+        """
+        now = time.time()
+        events = self._events[key]
+        while events and events[0] < now - self._max_window:
+            events.popleft()
+        for label, max_requests, window in self._tiers:
+            count = sum(1 for ts in events if ts >= now - window)
+            if count >= max_requests:
+                return label
+        events.append(now)
+        return None

{kryten_webqueue-0.33.1 → kryten_webqueue-0.33.2}/kryten_webqueue/routes/feedback.py

@@ -54,6 +54,26 @@ def _rate_limit(request: Request, key: str, message: str) -> None:
         raise HTTPException(status_code=429, detail=message)
 
 
+def _submission_quota(request: Request, key: str, noun: str) -> None:
+    """Enforce the hard per-user daily/weekly submission quota (2/day, 6/week).
+
+    Raises 429 with a tier-appropriate message when the day or week cap for
+    ``key`` is reached. A permitted submission is recorded against both tiers.
+    """
+    limiter = request.app.state.feedback_quota_limiter
+    exceeded = limiter.check(key)
+    if exceeded == "day":
+        raise HTTPException(
+            status_code=429,
+            detail=f"You've reached today's limit of 2 {noun}. Please try again tomorrow.",
+        )
+    if exceeded == "week":
+        raise HTTPException(
+            status_code=429,
+            detail=f"You've reached this week's limit of 6 {noun}. Please try again next week.",
+        )
+
+
 @router.post("/feedback/submit")
 async def submit_feedback(
     payload: FeedbackSubmit, request: Request, user: dict = Depends(get_current_user)
@@ -74,6 +94,7 @@ async def submit_feedback(
         f"feedback:{user['username']}",
         "You're sending feedback very quickly. Please wait a moment and try again.",
     )
+    _submission_quota(request, f"feedback:{user['username']}", "feedback submissions")
     db = request.app.state.db
     await db.add_feedback(username=user["username"], body=body)
     return {
@@ -144,6 +165,7 @@ async def submit_suggestion(
         f"suggest:{user['username']}",
         "You're sending suggestions very quickly. Please wait a moment and try again.",
     )
+    _submission_quota(request, f"suggest:{user['username']}", "suggestions")
     db = request.app.state.db
     username = user["username"]
     choice = payload.choice

{kryten_webqueue-0.33.1 → kryten_webqueue-0.33.2}/pyproject.toml

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

{kryten_webqueue-0.33.1 → kryten_webqueue-0.33.2}/tests/test_feedback.py

@@ -13,7 +13,7 @@ from fastapi import HTTPException
 
 from kryten_webqueue.catalog.db import Database
 from kryten_webqueue.catalog.images import CoverArtResolver
-from kryten_webqueue.auth.rate_limit import RateLimiter
+from kryten_webqueue.auth.rate_limit import QuotaLimiter, RateLimiter
 from kryten_webqueue.routes.feedback import (
     FeedbackSubmit,
     SuggestResolve,
@@ -63,6 +63,7 @@ async def _add_catalog(db, token, title):
 
 def _request(**state):
     """Minimal stand-in for a FastAPI Request exposing app.state.<attr>."""
+    state.setdefault("feedback_quota_limiter", _lenient_quota())
     return SimpleNamespace(app=SimpleNamespace(state=SimpleNamespace(**state)))
 
 
@@ -70,6 +71,10 @@ def _lenient_limiter():
     return RateLimiter(max_requests=100, window_seconds=300)
 
 
+def _lenient_quota():
+    return QuotaLimiter([("day", 1000, 86_400), ("week", 1000, 604_800)])
+
+
 class _FakeCover:
     """Stub cover-art resolver returning preset suggestion candidates."""
 
@@ -317,6 +322,55 @@ async def test_submit_feedback_rate_limited(db):
     assert ei.value.status_code == 429
 
 
+async def test_submit_feedback_daily_quota(db):
+    # 2 feedback submissions per day; the 3rd is rejected with a 429.
+    req = _request(
+        db=db,
+        feedback_rate_limiter=_lenient_limiter(),
+        feedback_quota_limiter=QuotaLimiter([("day", 2, 86_400), ("week", 6, 604_800)]),
+    )
+    await submit_feedback(FeedbackSubmit(body="one"), req, user=USER)
+    await submit_feedback(FeedbackSubmit(body="two"), req, user=USER)
+    with pytest.raises(HTTPException) as ei:
+        await submit_feedback(FeedbackSubmit(body="three"), req, user=USER)
+    assert ei.value.status_code == 429
+    assert "today" in ei.value.detail
+    assert await db.count_feedback() == 2
+
+
+async def test_submit_feedback_weekly_quota(db):
+    # 6 per week even when the daily cap is not the binding constraint.
+    req = _request(
+        db=db,
+        feedback_rate_limiter=_lenient_limiter(),
+        # High daily cap so only the weekly tier (6) can bind.
+        feedback_quota_limiter=QuotaLimiter(
+            [("day", 100, 86_400), ("week", 6, 604_800)]
+        ),
+    )
+    for i in range(6):
+        await submit_feedback(FeedbackSubmit(body=f"item {i}"), req, user=USER)
+    with pytest.raises(HTTPException) as ei:
+        await submit_feedback(FeedbackSubmit(body="seventh"), req, user=USER)
+    assert ei.value.status_code == 429
+    assert "week" in ei.value.detail
+    assert await db.count_feedback() == 6
+
+
+async def test_submit_feedback_quota_is_per_user(db):
+    # Each user gets an independent quota (namespaced keys).
+    req = _request(
+        db=db,
+        feedback_rate_limiter=_lenient_limiter(),
+        feedback_quota_limiter=QuotaLimiter([("day", 2, 86_400), ("week", 6, 604_800)]),
+    )
+    await submit_feedback(FeedbackSubmit(body="a"), req, user={"username": "Alice"})
+    await submit_feedback(FeedbackSubmit(body="b"), req, user={"username": "Alice"})
+    # Bob is unaffected by Alice reaching her cap.
+    res = await submit_feedback(FeedbackSubmit(body="c"), req, user={"username": "Bob"})
+    assert res["success"] is True
+
+
 # ── User routes: suggestions ────────────────────────────────────────────────
 
 
@@ -430,6 +484,24 @@ async def test_submit_suggestion_sanitizes_bad_source(db):
     assert row["resolution"] == "resolved"
 
 
+async def test_submit_suggestion_daily_quota(db):
+    # Suggestions share the same 2/day, 6/week cap (independent of feedback).
+    req = _request(
+        db=db,
+        feedback_rate_limiter=_lenient_limiter(),
+        feedback_quota_limiter=QuotaLimiter([("day", 2, 86_400), ("week", 6, 604_800)]),
+    )
+    await submit_suggestion(SuggestSubmit(query="one", unresolved=True), req, user=USER)
+    await submit_suggestion(SuggestSubmit(query="two", unresolved=True), req, user=USER)
+    with pytest.raises(HTTPException) as ei:
+        await submit_suggestion(
+            SuggestSubmit(query="three", unresolved=True), req, user=USER
+        )
+    assert ei.value.status_code == 429
+    assert "today" in ei.value.detail
+    assert await db.count_title_suggestions() == 2
+
+
 # ── Admin routes ────────────────────────────────────────────────────────────
 
 

kryten_webqueue-0.33.1/kryten_webqueue/auth/rate_limit.py

@@ -1,29 +0,0 @@
-import time
-from collections import defaultdict, deque
-
-
-class RateLimiter:
-    """Sliding-window rate limiter for OTP requests."""
-
-    def __init__(self, max_requests: int = 3, window_seconds: int = 300):
-        self._max = max_requests
-        self._window = window_seconds
-        self._requests: dict[str, deque] = defaultdict(deque)
-
-    def is_allowed(self, key: str) -> bool:
-        now = time.time()
-        window = self._requests[key]
-        # Remove expired entries
-        while window and window[0] < now - self._window:
-            window.popleft()
-        if len(window) >= self._max:
-            return False
-        window.append(now)
-        return True
-
-    def remaining(self, key: str) -> int:
-        now = time.time()
-        window = self._requests[key]
-        while window and window[0] < now - self._window:
-            window.popleft()
-        return max(0, self._max - len(window))