style: apply ruff format across backend + scripts (line-length 100)

Mechanical, whole-tree `ruff format` pass — no behaviour change. Recorded in
.git-blame-ignore-revs (next commit) so git blame skips it.

backend/app/routes/plex/_shared.py

@@ -31,11 +31,15 @@ def _content_libs(db: Session) -> tuple[list[int], list[int]]:
     """The BROWSABLE content libraries, partitioned into (movie_lib_ids, show_lib_ids) — the single
     source of the browse scope. Excludes HU overlay libraries (`overlay_of` set): those are never
     browsed on their own, they only lend their Hungarian metadata to the EN twin's rows (E5 S5)."""
-    libs = db.execute(
-        select(PlexLibrary).where(
-            PlexLibrary.enabled.is_(True), PlexLibrary.overlay_of.is_(None)
+    libs = (
+        db.execute(
+            select(PlexLibrary).where(
+                PlexLibrary.enabled.is_(True), PlexLibrary.overlay_of.is_(None)
+            )
         )
-    ).scalars().all()
+        .scalars()
+        .all()
+    )
     movie_lib_ids = [lb.id for lb in libs if lb.kind == "movie"]
     show_lib_ids = [lb.id for lb in libs if lb.kind == "show"]
     return movie_lib_ids, show_lib_ids

backend/app/routes/plex/admin.py

@@ -25,9 +25,7 @@ router = APIRouter(prefix="/api/plex", tags=["plex"])
 
 
 @router.post("/test")
-def test_connection(
-    _: User = Depends(admin_user), db: Session = Depends(get_db)
-) -> dict:
+def test_connection(_: User = Depends(admin_user), db: Session = Depends(get_db)) -> dict:
     """Admin: verify the configured Plex server URL + token, returning the server name and the
     movie/show sections (for the config library-picker). Also probes ONE real media file through
     the local mount, so a missing bind-mount / wrong path-map is caught here rather than only
@@ -59,9 +57,7 @@ def test_connection(
     }
 
 
-def _sample_plex_path(
-    db: Session, plex: PlexClient, sections: list[dict]
-) -> str | None:
+def _sample_plex_path(db: Session, plex: PlexClient, sections: list[dict]) -> str | None:
     """A real Plex-side media file path to validate the mount + path-map against. Prefers the
     already-mirrored catalog (cheap); before the first sync, pulls one movie leaf from an enabled
     section straight from Plex."""
@@ -113,13 +109,9 @@ def _link_dict(link: PlexLink | None) -> dict:
 
 
 @router.get("/watch/link")
-def watch_link_status(
-    user: User = Depends(current_user), db: Session = Depends(get_db)
-) -> dict:
+def watch_link_status(user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
     """This user's Plex watch-sync link status (drives the Settings toggle)."""
-    link = db.execute(
-        select(PlexLink).where(PlexLink.user_id == user.id)
-    ).scalars().first()
+    link = db.execute(select(PlexLink).where(PlexLink.user_id == user.id)).scalars().first()
     return _link_dict(link)
 
 
@@ -139,13 +131,9 @@ def watch_link_set(
     if not sysconfig.get_bool(db, "plex_enabled"):
         raise HTTPException(status_code=409, detail="The Plex module is disabled.")
     enabled = body.enabled
-    link = db.execute(
-        select(PlexLink).where(PlexLink.user_id == user.id)
-    ).scalars().first()
+    link = db.execute(select(PlexLink).where(PlexLink.user_id == user.id)).scalars().first()
     if link is None:
-        link = PlexLink(
-            user_id=user.id, uses_admin=True, linked_at=datetime.now(timezone.utc)
-        )
+        link = PlexLink(user_id=user.id, uses_admin=True, linked_at=datetime.now(timezone.utc))
         db.add(link)
     link.sync_enabled = enabled
     db.commit()
@@ -157,14 +145,10 @@ def watch_link_set(
 
 
 @router.post("/watch/import")
-def watch_import_now(
-    user: User = Depends(admin_user), db: Session = Depends(get_db)
-) -> dict:
+def watch_import_now(user: User = Depends(admin_user), db: Session = Depends(get_db)) -> dict:
     """Admin: (re-)run the "Plex is master" import for this account — Plex re-wins on the
     intersection; Siftlode-only states are preserved. Idempotent."""
-    link = db.execute(
-        select(PlexLink).where(PlexLink.user_id == user.id)
-    ).scalars().first()
+    link = db.execute(select(PlexLink).where(PlexLink.user_id == user.id)).scalars().first()
     if link is None or not link.sync_enabled:
         raise HTTPException(status_code=409, detail="Enable Plex watch-sync first.")
     result = plex_watch.import_owner_watch_state(db, link)

backend/app/routes/plex/browse.py

@@ -50,16 +50,18 @@ router = APIRouter(prefix="/api/plex", tags=["plex"])
 
 
 @router.get("/libraries")
-def list_libraries(
-    user: User = Depends(current_user), db: Session = Depends(get_db)
-) -> dict:
+def list_libraries(user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
     """The mirrored libraries the user can browse (drives the Plex scope selector). HU overlay
     libraries are excluded — they're not browsable, they only feed the EN twin's Hungarian metadata."""
-    libs = db.execute(
-        select(PlexLibrary)
-        .where(PlexLibrary.overlay_of.is_(None))
-        .order_by(PlexLibrary.kind.desc(), PlexLibrary.title)
-    ).scalars().all()
+    libs = (
+        db.execute(
+            select(PlexLibrary)
+            .where(PlexLibrary.overlay_of.is_(None))
+            .order_by(PlexLibrary.kind.desc(), PlexLibrary.title)
+        )
+        .scalars()
+        .all()
+    )
     out = []
     for lib in libs:
         if lib.kind == "movie":
@@ -69,9 +71,7 @@ def list_libraries(
                 )
             )
         else:
-            count = db.scalar(
-                select(func.count(PlexShow.id)).where(PlexShow.library_id == lib.id)
-            )
+            count = db.scalar(select(func.count(PlexShow.id)).where(PlexShow.library_id == lib.id))
         out.append(
             {
                 "key": lib.plex_key,
@@ -116,9 +116,7 @@ def unified_library(
     # `episode` scope targets episode rows only — the movie/show grid stays empty; the recheck for
     # the specific title/people/summary fields is a strict narrowing on top of the GIN prefilter.
     grid_field = field != "episode"
-    recheck = (
-        field_recheck if tsq is not None and field not in ("all", "episode") else None
-    )
+    recheck = field_recheck if tsq is not None and field not in ("all", "episode") else None
 
     selects = []
     if want_movies and grid_field:
@@ -201,9 +199,7 @@ def unified_library(
     items = []
     total = 0
     if selects:
-        union = (
-            selects[0] if len(selects) == 1 else selects[0].union_all(*selects[1:])
-        )
+        union = selects[0] if len(selects) == 1 else selects[0].union_all(*selects[1:])
         u = union.subquery()
         total = db.scalar(select(func.count()).select_from(u)) or 0
 
@@ -219,9 +215,7 @@ def unified_library(
             }.get(sort, u.c.added_at)
             order = [(col.asc() if sort_dir == "asc" else col.desc()).nullslast()]
         order.append(u.c.rk.desc())
-        rows = db.execute(
-            select(u).order_by(*order).offset(offset).limit(limit)
-        ).all()
+        rows = db.execute(select(u).order_by(*order).offset(offset).limit(limit)).all()
 
         for r in rows:
             if r.kind == "movie":
@@ -268,9 +262,7 @@ def unified_library(
         )
         eps = db.execute(
             select(PlexItem, ep_st, PlexShow.title.label("show_title"))
-            .outerjoin(
-                ep_st, and_(ep_st.item_id == PlexItem.id, ep_st.user_id == user.id)
-            )
+            .outerjoin(ep_st, and_(ep_st.item_id == PlexItem.id, ep_st.user_id == user.id))
             .outerjoin(PlexShow, PlexShow.id == PlexItem.show_id)
             .where(
                 PlexItem.kind == "episode",
@@ -389,9 +381,7 @@ def facets(
             .where(func.jsonb_typeof(gcol) == "array")
             .subquery()
         )
-        for g, c in db.execute(
-            select(expanded.c.g, func.count()).group_by(expanded.c.g)
-        ).all():
+        for g, c in db.execute(select(expanded.c.g, func.count()).group_by(expanded.c.g)).all():
             genre_counts[g] = genre_counts.get(g, 0) + c
         # Content ratings — exclude its own.
         crq = (
@@ -482,12 +472,10 @@ def facets(
         studio_counts.setdefault(s, 0)
     return {
         "genres": [
-            {"value": g, "count": c}
-            for g, c in sorted(genre_counts.items(), key=lambda kv: kv[0])
+            {"value": g, "count": c} for g, c in sorted(genre_counts.items(), key=lambda kv: kv[0])
         ],
         "content_ratings": [
-            {"value": cr, "count": c}
-            for cr, c in sorted(cr_counts.items(), key=lambda kv: -kv[1])
+            {"value": cr, "count": c} for cr, c in sorted(cr_counts.items(), key=lambda kv: -kv[1])
         ],
         "studios": [
             {"value": s, "count": c}

backend/app/routes/plex/collections.py

@@ -25,10 +25,16 @@ from app.routes.plex._shared import _content_libs
 # The most-restrictive → least ordering used to pick a collection's effective content rating from its
 # members (Plex shows one cert on the collection; we don't store it, so derive it).
 _CERT_RANK = {
-    "G": 1, "TV-Y": 1, "TV-Y7": 1, "TV-G": 1,
-    "PG": 2, "TV-PG": 2,
-    "PG-13": 3, "TV-14": 3,
-    "R": 4, "TV-MA": 4,
+    "G": 1,
+    "TV-Y": 1,
+    "TV-Y7": 1,
+    "TV-G": 1,
+    "PG": 2,
+    "TV-PG": 2,
+    "PG-13": 3,
+    "TV-14": 3,
+    "R": 4,
+    "TV-MA": 4,
     "NC-17": 5,
 }
 
@@ -37,6 +43,7 @@ def _collection_cert(certs: list[str | None]) -> str | None:
     ranked = [(c, _CERT_RANK.get(c, 0)) for c in certs if c]
     return max(ranked, key=lambda x: x[1])[0] if ranked else None
 
+
 router = APIRouter(prefix="/api/plex", tags=["plex"])
 
 _STRIP_PROVIDERS = ("imdb", "tmdb", "tvdb", "trakt")
@@ -85,9 +92,11 @@ def collections(
     the UNION across all enabled libraries (the unified-scope sidebar picker, which has no single
     library selected)."""
     if library is not None:
-        lib = db.execute(
-            select(PlexLibrary).where(PlexLibrary.plex_key == str(library))
-        ).scalars().first()
+        lib = (
+            db.execute(select(PlexLibrary).where(PlexLibrary.plex_key == str(library)))
+            .scalars()
+            .first()
+        )
         if lib is None:
             return {"collections": []}
         query = select(PlexCollection).where(PlexCollection.library_id == lib.id)
@@ -101,18 +110,20 @@ def collections(
         )
         if not enabled_ids:
             return {"collections": []}
-        query = select(PlexCollection).where(
-            PlexCollection.library_id.in_(enabled_ids)
-        )
+        query = select(PlexCollection).where(PlexCollection.library_id.in_(enabled_ids))
     term = (q or "").strip()
     if term:
         query = query.where(PlexCollection.title.ilike(f"%{like_escape(term)}%"))
-    rows = db.execute(
-        query.order_by(
-            PlexCollection.child_count.desc().nullslast(),
-            func.lower(PlexCollection.title),
+    rows = (
+        db.execute(
+            query.order_by(
+                PlexCollection.child_count.desc().nullslast(),
+                func.lower(PlexCollection.title),
+            )
         )
-    ).scalars().all()
+        .scalars()
+        .all()
+    )
     # A montage of the top titles per tile + the collection's total runtime. Art unions MOVIE and SHOW
     # members (a collection lives in one library, so exactly one side has art) — a show collection would
     # otherwise render blank; the collection's own poster is the next fallback, then the colour hash.
@@ -150,16 +161,24 @@ def collection_detail(
     col = by_rating_key(db, PlexCollection, rating_key)
     if col is None:
         raise HTTPException(status_code=404, detail="Unknown collection")
-    movies = db.execute(
-        select(PlexItem)
-        .where(PlexItem.kind == "movie", PlexItem.collection_keys.contains([rating_key]))
-        .order_by(PlexItem.year.asc().nullslast(), func.lower(PlexItem.title))
-    ).scalars().all()
-    shows = db.execute(
-        select(PlexShow)
-        .where(PlexShow.collection_keys.contains([rating_key]))
-        .order_by(PlexShow.year.asc().nullslast(), func.lower(PlexShow.title))
-    ).scalars().all()
+    movies = (
+        db.execute(
+            select(PlexItem)
+            .where(PlexItem.kind == "movie", PlexItem.collection_keys.contains([rating_key]))
+            .order_by(PlexItem.year.asc().nullslast(), func.lower(PlexItem.title))
+        )
+        .scalars()
+        .all()
+    )
+    shows = (
+        db.execute(
+            select(PlexShow)
+            .where(PlexShow.collection_keys.contains([rating_key]))
+            .order_by(PlexShow.year.asc().nullslast(), func.lower(PlexShow.title))
+        )
+        .scalars()
+        .all()
+    )
     mstate = rollup.item_state_map(db, user.id, [m.id for m in movies])
     sstate = rollup.state_map(db, user.id, [s.id for s in shows])
     # Merge the two type-homogeneous lists into ONE member list ordered by (year, title).
@@ -168,7 +187,9 @@ def collection_detail(
     ]
     tagged.sort(key=lambda t: (t[0] is None, t[0] or 0, t[1]))
     items = [
-        movie_card(o, mstate.get(o.id)) if kind == "movie" else show_card(o, sstate.get(o.id, "new"))
+        movie_card(o, mstate.get(o.id))
+        if kind == "movie"
+        else show_card(o, sstate.get(o.id, "new"))
         for _, _, kind, o in tagged
     ]
     years = [y for y, _, _, _ in tagged if y is not None]
@@ -198,12 +219,16 @@ def _reject_duplicate_name(
     """No two collections in a section may share a name: Plex CONFLATES same-named collections'
     membership (both rating_keys resolve to one merged member list — a real footgun), so forbid it up
     front on create + rename rather than mirror the mess."""
-    dup = db.execute(
-        select(PlexCollection).where(
-            PlexCollection.library_id == library_id,
-            func.lower(PlexCollection.title) == title.lower(),
+    dup = (
+        db.execute(
+            select(PlexCollection).where(
+                PlexCollection.library_id == library_id,
+                func.lower(PlexCollection.title) == title.lower(),
+            )
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     if dup is not None and dup.rating_key != exclude_rk:
         raise HTTPException(status_code=409, detail="A collection with this name already exists")
 
@@ -244,13 +269,11 @@ def create_collection(
     title = body.title.strip()
     seed = body.item_rating_key
     if not title or not seed:
-        raise HTTPException(
-            status_code=400, detail="title and item_rating_key are required"
-        )
+        raise HTTPException(status_code=400, detail="title and item_rating_key are required")
     if library:
-        lib = db.execute(
-            select(PlexLibrary).where(PlexLibrary.plex_key == library)
-        ).scalars().first()
+        lib = (
+            db.execute(select(PlexLibrary).where(PlexLibrary.plex_key == library)).scalars().first()
+        )
     else:
         # The "New collection" flow only knows the seed title → derive its library.
         seed_item = by_rating_key(db, PlexItem, seed) or by_rating_key(db, PlexShow, seed)

backend/app/routes/plex/detail.py

@@ -62,9 +62,7 @@ def _show_enrichment(db: Session, rating_key: str) -> tuple[dict, list]:
         with PlexClient(db) as plex:
             with ThreadPoolExecutor(max_workers=2) as ex:
                 meta_f = ex.submit(plex.metadata, rating_key)
-                related_f = ex.submit(
-                    plex.related, rating_key
-                )  # swallows its own errors → []
+                related_f = ex.submit(plex.related, rating_key)  # swallows its own errors → []
                 meta = meta_f.result() or {}
                 related_raw = related_f.result()
     except (PlexError, PlexNotConfigured):
@@ -95,19 +93,27 @@ def show_detail(
     sh = by_rating_key(db, PlexShow, rating_key)
     if sh is None:
         raise HTTPException(status_code=404, detail="Unknown Plex show")
-    seasons = db.execute(
-        select(PlexSeason)
-        .where(PlexSeason.show_id == sh.id)
-        .order_by(PlexSeason.season_number.asc().nullsfirst())
-    ).scalars().all()
-    eps = db.execute(
-        select(PlexItem)
-        .where(PlexItem.show_id == sh.id, PlexItem.kind == "episode")
-        .order_by(
-            PlexItem.season_number.asc().nullsfirst(),
-            PlexItem.episode_number.asc().nullsfirst(),
+    seasons = (
+        db.execute(
+            select(PlexSeason)
+            .where(PlexSeason.show_id == sh.id)
+            .order_by(PlexSeason.season_number.asc().nullsfirst())
         )
-    ).scalars().all()
+        .scalars()
+        .all()
+    )
+    eps = (
+        db.execute(
+            select(PlexItem)
+            .where(PlexItem.show_id == sh.id, PlexItem.kind == "episode")
+            .order_by(
+                PlexItem.season_number.asc().nullsfirst(),
+                PlexItem.episode_number.asc().nullsfirst(),
+            )
+        )
+        .scalars()
+        .all()
+    )
     states = {
         s.item_id: s
         for s in db.execute(
@@ -118,9 +124,7 @@ def show_detail(
         ).scalars()
     }
     by_season: dict[int | None, list] = {}
-    all_cards: list[
-        dict
-    ] = []  # every episode, in season/episode order → show-level rollup
+    all_cards: list[dict] = []  # every episode, in season/episode order → show-level rollup
     for e in eps:
         card = episode_card(e, states.get(e.id))
         by_season.setdefault(e.season_id, []).append(card)
@@ -188,8 +192,7 @@ def _season_block(se: PlexSeason, cards: list[dict]) -> dict:
     return {
         "id": se.rating_key,
         "season_number": se.season_number,
-        "title": se.title
-        or (f"Season {se.season_number}" if se.season_number else "Season"),
+        "title": se.title or (f"Season {se.season_number}" if se.season_number else "Season"),
         "thumb": f"/api/plex/image/{se.rating_key}",
         "episode_count": roll["episode_count"],
         "status": roll["status"],
@@ -199,9 +202,7 @@ def _season_block(se: PlexSeason, cards: list[dict]) -> dict:
     }
 
 
-def _relatedshow_cards(
-    db: Session, user_id: int, related: list[dict], exclude: int
-) -> list[dict]:
+def _relatedshow_cards(db: Session, user_id: int, related: list[dict], exclude: int) -> list[dict]:
     """Map Plex 'related' metadata to show cards for the shows we actually mirror (so they're openable),
     excluding the current show. Order preserved; capped."""
     rks = [str(m.get("ratingKey")) for m in related if m.get("ratingKey")]
@@ -210,9 +211,7 @@ def _relatedshow_cards(
     shows = {
         s.rating_key: s
         for s in db.execute(
-            select(PlexShow).where(
-                PlexShow.rating_key.in_(rks[:60]), PlexShow.id != exclude
-            )
+            select(PlexShow).where(PlexShow.rating_key.in_(rks[:60]), PlexShow.id != exclude)
         ).scalars()
     }
     statuses = rollup.state_map(db, user_id, [s.id for s in shows.values()])
@@ -242,22 +241,24 @@ def _collection_strips(db: Session, it: PlexItem, user_id: int) -> list[dict]:
         ).scalars()
     }
     # Smallest (most specific — e.g. a franchise) first; the big auto-lists (IMDb/TMDb Popular) last.
-    ordered = sorted(
-        (c for c in cols.values()), key=lambda c: (c.child_count or 0, c.title)
-    )
+    ordered = sorted((c for c in cols.values()), key=lambda c: (c.child_count or 0, c.title))
     out = []
     for col in ordered:
         rk = col.rating_key
-        members = db.execute(
-            select(PlexItem)
-            .where(
-                PlexItem.library_id == it.library_id,
-                PlexItem.kind == "movie",
-                PlexItem.collection_keys.contains([rk]),
+        members = (
+            db.execute(
+                select(PlexItem)
+                .where(
+                    PlexItem.library_id == it.library_id,
+                    PlexItem.kind == "movie",
+                    PlexItem.collection_keys.contains([rk]),
+                )
+                .order_by(PlexItem.year.asc().nullslast(), func.lower(PlexItem.title))
+                .limit(60)
             )
-            .order_by(PlexItem.year.asc().nullslast(), func.lower(PlexItem.title))
-            .limit(60)
-        ).scalars().all()
+            .scalars()
+            .all()
+        )
         ids = [m.id for m in members]
         states = {
             s.item_id: s
@@ -295,9 +296,7 @@ def _episode_nav(db: Session, it: PlexItem) -> tuple[str | None, str | None]:
         i = keys.index(it.rating_key)
     except ValueError:
         return None, None
-    return (keys[i - 1] if i > 0 else None), (
-        keys[i + 1] if i < len(keys) - 1 else None
-    )
+    return (keys[i - 1] if i > 0 else None), (keys[i + 1] if i < len(keys) - 1 else None)
 
 
 @router.get("/item/{rating_key}")
@@ -311,11 +310,13 @@ def item_detail(
     prev/next, and the per-user resume position + watch status."""
     lang = _norm_lang(lang)
     it = item_or_404(db, rating_key)
-    st = db.execute(
-        select(PlexState).where(
-            PlexState.user_id == user.id, PlexState.item_id == it.id
+    st = (
+        db.execute(
+            select(PlexState).where(PlexState.user_id == user.id, PlexState.item_id == it.id)
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
 
     # Markers + audio/subtitle streams are file-specific, so they stay LIVE; the rich detail (cast/IMDb/
     # tagline/genres) is served from the DB row for movies (persisted below / by the backfill) and only
@@ -430,9 +431,7 @@ def item_detail(
         "subtitle_streams": subtitle_streams,
         "status": st.status if st else "new",
         "position_seconds": st.position_seconds if st else 0,
-        "show_title": (
-            (show.title_hu or show.title if hu else show.title) if show else None
-        ),
+        "show_title": ((show.title_hu or show.title if hu else show.title) if show else None),
         "season_number": it.season_number,
         "episode_number": it.episode_number,
         "prev_id": prev_id,

backend/app/routes/plex/discover.py

@@ -71,7 +71,13 @@ def _show_cards(db: Session, uid: int, shows: list[PlexShow]) -> list[dict]:
 
 
 def _recently_added(
-    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+    db: Session,
+    uid: int,
+    movie_ids: list[int],
+    show_ids: list[int],
+    p: dict,
+    lang: str,
+    f: LibraryFilters,
 ) -> list[dict]:
     """Newest movies + shows, interleaved by `added_at` desc into one rail."""
     movies = (
@@ -80,11 +86,15 @@ def _recently_added(
                 select(PlexItem).where(
                     PlexItem.kind == "movie", PlexItem.library_id.in_(movie_ids)
                 ),
-                p, lang, f,
+                p,
+                lang,
+                f,
             )
             .order_by(PlexItem.added_at.desc().nullslast())
             .limit(RAIL_LIMIT)
-        ).scalars().all()
+        )
+        .scalars()
+        .all()
         if movie_ids
         else []
     )
@@ -95,16 +105,16 @@ def _recently_added(
             )
             .order_by(PlexShow.added_at.desc().nullslast())
             .limit(RAIL_LIMIT)
-        ).scalars().all()
+        )
+        .scalars()
+        .all()
         if show_ids
         else []
     )
     # Merge the two type-homogeneous lists by added_at, then serialize each side in one batch so the
     # per-card state lookups stay batched (no N+1). The `(is not None, value)` key sorts a missing
     # timestamp last under reverse.
-    tagged = [(m.added_at, "movie", m) for m in movies] + [
-        (s.added_at, "show", s) for s in shows
-    ]
+    tagged = [(m.added_at, "movie", m) for m in movies] + [(s.added_at, "show", s) for s in shows]
     tagged.sort(key=lambda t: (t[0] is not None, t[0]), reverse=True)
     top = tagged[:RAIL_LIMIT]
     # Key the serialized cards back by rating_key (globally unique in Plex — a movie and a show never
@@ -113,14 +123,17 @@ def _recently_added(
     top_shows = [o for _, kind, o in top if kind == "show"]
     mcards = {m.rating_key: c for m, c in zip(top_movies, _movie_cards(db, uid, top_movies))}
     scards = {s.rating_key: c for s, c in zip(top_shows, _show_cards(db, uid, top_shows))}
-    return [
-        mcards[o.rating_key] if kind == "movie" else scards[o.rating_key]
-        for _, kind, o in top
-    ]
+    return [mcards[o.rating_key] if kind == "movie" else scards[o.rating_key] for _, kind, o in top]
 
 
 def _recently_watched(
-    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+    db: Session,
+    uid: int,
+    movie_ids: list[int],
+    show_ids: list[int],
+    p: dict,
+    lang: str,
+    f: LibraryFilters,
 ) -> list[dict]:
     """Recently watched rail: the titles the user last FULLY watched, newest first. A movie is its own
     card; a show contributes the specific EPISODE watched (carrying its show title). Movies honour the
@@ -162,7 +175,13 @@ def _recently_watched(
 
 
 def _continue_watching(
-    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+    db: Session,
+    uid: int,
+    movie_ids: list[int],
+    show_ids: list[int],
+    p: dict,
+    lang: str,
+    f: LibraryFilters,
 ) -> list[dict]:
     """Resume rail: in-progress movies + partially-watched shows, most-recently-progressed first.
     A movie's resume time is its own `progress_updated_at`; a show's is the max across its episodes."""
@@ -238,9 +257,7 @@ def _genre_tiles(
         if model is PlexItem:
             base = base.where(model.kind == "movie")
         expanded = base.subquery()
-        for g, c in db.execute(
-            select(expanded.c.g, func.count()).group_by(expanded.c.g)
-        ).all():
+        for g, c in db.execute(select(expanded.c.g, func.count()).group_by(expanded.c.g)).all():
             counts[g] = counts.get(g, 0) + c
     top = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[:GENRE_TILES]
     # A 2×2 poster collage per tile: the top movies in that genre (color hash is the client fallback).
@@ -256,7 +273,13 @@ def _genre_tiles(
 
 
 def _because_you_watched(
-    db: Session, uid: int, movie_ids: list[int], show_ids: list[int], p: dict, lang: str, f: LibraryFilters
+    db: Session,
+    uid: int,
+    movie_ids: list[int],
+    show_ids: list[int],
+    p: dict,
+    lang: str,
+    f: LibraryFilters,
 ) -> dict | None:
     """Recommendations anchored on the user's most-recently-watched, TMDB-enriched movie. Only the
     recs that resolve to OUR library (by guid) become cards — the rest aren't actionable here. Returns
@@ -264,21 +287,25 @@ def _because_you_watched(
     The metadata filters narrow the resolved recs (not the anchor pick) so the rail matches the grid."""
     if not movie_ids:
         return None
-    anchor = db.execute(
-        select(PlexItem)
-        .join(
-            PlexState,
-            and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid),
+    anchor = (
+        db.execute(
+            select(PlexItem)
+            .join(
+                PlexState,
+                and_(PlexState.item_id == PlexItem.id, PlexState.user_id == uid),
+            )
+            .where(
+                PlexItem.kind == "movie",
+                PlexItem.library_id.in_(movie_ids),
+                PlexState.status == "watched",
+                PlexItem.recommendations.isnot(None),
+            )
+            .order_by(PlexState.watched_at.desc().nullslast())
+            .limit(1)
         )
-        .where(
-            PlexItem.kind == "movie",
-            PlexItem.library_id.in_(movie_ids),
-            PlexState.status == "watched",
-            PlexItem.recommendations.isnot(None),
-        )
-        .order_by(PlexState.watched_at.desc().nullslast())
-        .limit(1)
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     if anchor is None:
         return None
     resolved = resolve_recs(db, anchor.recommendations)
@@ -294,12 +321,14 @@ def _because_you_watched(
         m.rating_key: m
         for m in db.execute(
             _movie_meta(
-                select(PlexItem).where(
-                    PlexItem.kind == "movie", PlexItem.rating_key.in_(rks)
-                ),
-                p, lang, f,
+                select(PlexItem).where(PlexItem.kind == "movie", PlexItem.rating_key.in_(rks)),
+                p,
+                lang,
+                f,
             )
-        ).scalars().all()
+        )
+        .scalars()
+        .all()
     }
     shows = {
         s.rating_key: s
@@ -307,12 +336,16 @@ def _because_you_watched(
             apply_meta_filters(
                 select(PlexShow).where(PlexShow.rating_key.in_(rks)), PlexShow, p, lang
             )
-        ).scalars().all()
+        )
+        .scalars()
+        .all()
     }
     ordered_movies = [movies[rk] for rk in rks if rk in movies]
     ordered_shows = [shows[rk] for rk in rks if rk in shows]
     # rating_key is globally unique in Plex, so it keys the serialized cards back safely (no id()).
-    mcards = {m.rating_key: c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies))}
+    mcards = {
+        m.rating_key: c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies))
+    }
     scards = {s.rating_key: c for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows))}
     items: list[dict] = []
     for rk in rks:
@@ -379,18 +412,24 @@ def surprise(
             )
             .exists()
         )
-        movies = db.execute(
-            _movie_meta(
-                select(PlexItem).where(
-                    PlexItem.kind == "movie",
-                    PlexItem.library_id.in_(movie_ids),
-                    ~watched_movie,
-                ),
-                p, lang, f,
+        movies = (
+            db.execute(
+                _movie_meta(
+                    select(PlexItem).where(
+                        PlexItem.kind == "movie",
+                        PlexItem.library_id.in_(movie_ids),
+                        ~watched_movie,
+                    ),
+                    p,
+                    lang,
+                    f,
+                )
+                .order_by(func.random())
+                .limit(per)
             )
-            .order_by(func.random())
-            .limit(per)
-        ).scalars().all()
+            .scalars()
+            .all()
+        )
     shows = []
     if show_ids:
         # Exclude fully-watched shows (LEFT JOIN so a never-started show — no rollup row — still counts
@@ -399,16 +438,22 @@ def surprise(
         not_fully_watched = or_(
             prog.c.total.is_(None), prog.c.total == 0, prog.c.watched < prog.c.total
         )
-        shows = db.execute(
-            apply_meta_filters(
-                select(PlexShow)
-                .outerjoin(prog, prog.c.show_id == PlexShow.id)
-                .where(PlexShow.library_id.in_(show_ids), not_fully_watched),
-                PlexShow, p, lang,
+        shows = (
+            db.execute(
+                apply_meta_filters(
+                    select(PlexShow)
+                    .outerjoin(prog, prog.c.show_id == PlexShow.id)
+                    .where(PlexShow.library_id.in_(show_ids), not_fully_watched),
+                    PlexShow,
+                    p,
+                    lang,
+                )
+                .order_by(func.random())
+                .limit(per)
             )
-            .order_by(func.random())
-            .limit(per)
-        ).scalars().all()
+            .scalars()
+            .all()
+        )
     mcards = _movie_cards(db, user.id, movies)
     scards = _show_cards(db, user.id, shows)
     # Interleave movie/show cards, then trim to `limit`.

backend/app/routes/plex/people.py

@@ -76,9 +76,7 @@ def people_cards(
     want_shows = scope in ("show", "both") and bool(show_lib_ids)
     photos = {
         p.name: p.photo_thumb
-        for p in db.execute(
-            select(PlexPerson).where(PlexPerson.name.in_(wanted))
-        ).scalars()
+        for p in db.execute(select(PlexPerson).where(PlexPerson.name.in_(wanted))).scalars()
     }
     out = []
     for nm in wanted:
@@ -191,36 +189,44 @@ def person_detail(
 
     movies: list[dict] = []
     if movie_lib_ids:
-        items = db.execute(
-            select(PlexItem)
-            .where(
-                PlexItem.kind == "movie",
-                PlexItem.library_id.in_(movie_lib_ids),
-                or_(
-                    PlexItem.cast_names.contains([name]),
-                    PlexItem.directors.contains([name]),
-                ),
+        items = (
+            db.execute(
+                select(PlexItem)
+                .where(
+                    PlexItem.kind == "movie",
+                    PlexItem.library_id.in_(movie_lib_ids),
+                    or_(
+                        PlexItem.cast_names.contains([name]),
+                        PlexItem.directors.contains([name]),
+                    ),
+                )
+                .order_by(PlexItem.year.desc().nullslast(), func.lower(PlexItem.title))
+                .limit(_PERSON_SECTION_MAX)
             )
-            .order_by(PlexItem.year.desc().nullslast(), func.lower(PlexItem.title))
-            .limit(_PERSON_SECTION_MAX)
-        ).scalars().all()
+            .scalars()
+            .all()
+        )
         states = rollup.item_state_map(db, user.id, [it.id for it in items])
         movies = [movie_card(it, states.get(it.id)) for it in items]
 
     shows: list[dict] = []
     if show_lib_ids:
-        show_rows = db.execute(
-            select(PlexShow)
-            .where(
-                PlexShow.library_id.in_(show_lib_ids),
-                or_(
-                    PlexShow.cast_names.contains([name]),
-                    PlexShow.directors.contains([name]),
-                ),
+        show_rows = (
+            db.execute(
+                select(PlexShow)
+                .where(
+                    PlexShow.library_id.in_(show_lib_ids),
+                    or_(
+                        PlexShow.cast_names.contains([name]),
+                        PlexShow.directors.contains([name]),
+                    ),
+                )
+                .order_by(PlexShow.year.desc().nullslast(), func.lower(PlexShow.title))
+                .limit(_PERSON_SECTION_MAX)
             )
-            .order_by(PlexShow.year.desc().nullslast(), func.lower(PlexShow.title))
-            .limit(_PERSON_SECTION_MAX)
-        ).scalars().all()
+            .scalars()
+            .all()
+        )
         statuses = rollup.state_map(db, user.id, [s.id for s in show_rows])
         shows = [show_card(sh, statuses.get(sh.id, "new")) for sh in show_rows]
 

backend/app/routes/plex/playback.py

@@ -76,9 +76,7 @@ def image(rating_key: str, request: Request, variant: str = "thumb") -> Response
             key = imgcache.key_for(db, str(rating_key), v)
             if not key:
                 raise HTTPException(status_code=404, detail="No image")
-            plex = PlexClient(
-                db
-            )  # reads base URL + token now; the fetch below needs no DB
+            plex = PlexClient(db)  # reads base URL + token now; the fetch below needs no DB
     except PlexNotConfigured as e:
         raise HTTPException(status_code=400, detail=str(e))
     try:
@@ -91,9 +89,7 @@ def image(rating_key: str, request: Request, variant: str = "thumb") -> Response
 
 
 @router.get("/subtitle/{rating_key}/{sub_ord}")
-def subtitle(
-    rating_key: str, sub_ord: int, request: Request, offset: float = 0.0
-) -> Response:
+def subtitle(rating_key: str, sub_ord: int, request: Request, offset: float = 0.0) -> Response:
     """Serve the ord-th subtitle track as WebVTT for the browser's <track> — so choosing a subtitle
     overlays it directly (no HLS re-mux / session restart). Handles EXTERNAL sidecar subs (fetched
     from Plex via the stream `key` — the old `-map 0:s` broke on these since they're not in the file)
@@ -109,12 +105,10 @@ def subtitle(
         with SessionLocal() as db:
             it = item_or_404(db, rating_key)
             with PlexClient(db) as plex:
-                part = ((plex.metadata(it.rating_key) or {}).get("Media") or [{}])[
-                    0
-                ].get("Part") or [{}]
-                subs = [
-                    s for s in (part[0].get("Stream") or []) if s.get("streamType") == 3
-                ]
+                part = ((plex.metadata(it.rating_key) or {}).get("Media") or [{}])[0].get(
+                    "Part"
+                ) or [{}]
+                subs = [s for s in (part[0].get("Stream") or []) if s.get("streamType") == 3]
                 if sub_ord < 0 or sub_ord >= len(subs):
                     raise HTTPException(status_code=404, detail="No such subtitle")
                 s = subs[sub_ord]
@@ -136,22 +130,14 @@ def subtitle(
                             vtt = subtitles.ffmpeg_to_vtt(tmp, None)
                         finally:
                             os.unlink(tmp)
-                elif (
-                    s.get("index") is not None
-                ):  # embedded → extract from the local file
+                elif s.get("index") is not None:  # embedded → extract from the local file
                     src = plex_paths.local_media_path(db, it.file_path)
                     if src is None:
-                        raise HTTPException(
-                            status_code=404, detail="Media file not found on disk"
-                        )
-                    emb_ord = sum(
-                        1 for x in subs[:sub_ord] if x.get("index") is not None
-                    )
+                        raise HTTPException(status_code=404, detail="Media file not found on disk")
+                    emb_ord = sum(1 for x in subs[:sub_ord] if x.get("index") is not None)
                     vtt = subtitles.ffmpeg_to_vtt(str(src), emb_ord)
                 else:
-                    raise HTTPException(
-                        status_code=404, detail="Subtitle not fetchable"
-                    )
+                    raise HTTPException(status_code=404, detail="Subtitle not fetchable")
     except PlexNotConfigured as e:
         raise HTTPException(status_code=400, detail=str(e))
     except PlexError as e:
@@ -209,11 +195,13 @@ def _push_watch(
         return
     # Capture the row's freshest timestamp NOW so the background push can tell if a newer local edit
     # lands before it settles synced_to_plex (which would otherwise strand that newer value).
-    st = db.execute(
-        select(PlexState).where(
-            PlexState.user_id == user_id, PlexState.item_id == item_id
+    st = (
+        db.execute(
+            select(PlexState).where(PlexState.user_id == user_id, PlexState.item_id == item_id)
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     background.add_task(
         plex_watch.push_state_to_plex,
         user_id,
@@ -252,11 +240,13 @@ def item_progress(
     duration = int(body.duration_seconds)
     final = body.final
     now = datetime.now(timezone.utc)
-    st = db.execute(
-        select(PlexState).where(
-            PlexState.user_id == user.id, PlexState.item_id == it.id
+    st = (
+        db.execute(
+            select(PlexState).where(PlexState.user_id == user.id, PlexState.item_id == it.id)
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     was_watched = st is not None and st.status == "watched"
 
     near_end = duration > 0 and position > duration - _FINISH_MARGIN_S
@@ -326,11 +316,13 @@ def item_state(
     status = body.status
     if status not in ("new", "watched", "hidden"):
         raise HTTPException(status_code=400, detail="Invalid status")
-    st = db.execute(
-        select(PlexState).where(
-            PlexState.user_id == user.id, PlexState.item_id == it.id
+    st = (
+        db.execute(
+            select(PlexState).where(PlexState.user_id == user.id, PlexState.item_id == it.id)
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     prev_status = st.status if st is not None else "new"
     if status == "new":
         if st is not None:
@@ -417,9 +409,11 @@ def show_state(
     if sh is None:
         raise HTTPException(status_code=404, detail="Unknown Plex show")
     watched = body.watched
-    eps = db.execute(
-        select(PlexItem).where(PlexItem.show_id == sh.id, PlexItem.kind == "episode")
-    ).scalars().all()
+    eps = (
+        db.execute(select(PlexItem).where(PlexItem.show_id == sh.id, PlexItem.kind == "episode"))
+        .scalars()
+        .all()
+    )
     changed = _bulk_state(background, db, user.id, eps, watched)
     return {"changed": changed, "watched": watched}
 
@@ -437,9 +431,11 @@ def season_state(
     if se is None:
         raise HTTPException(status_code=404, detail="Unknown Plex season")
     watched = body.watched
-    eps = db.execute(
-        select(PlexItem).where(PlexItem.season_id == se.id, PlexItem.kind == "episode")
-    ).scalars().all()
+    eps = (
+        db.execute(select(PlexItem).where(PlexItem.season_id == se.id, PlexItem.kind == "episode"))
+        .scalars()
+        .all()
+    )
     changed = _bulk_state(background, db, user.id, eps, watched)
     return {"changed": changed, "watched": watched}
 
@@ -504,9 +500,7 @@ def stream_file(
         # A clean, safe download name from the title + the real file extension.
         ext = src.suffix or (f".{it.container}" if it.container else "")
         base = (
-            "".join(
-                c for c in (it.title or "video") if c.isalnum() or c in " -_."
-            ).strip()
+            "".join(c for c in (it.title or "video") if c.isalnum() or c in " -_.").strip()
             or "video"
         )
         return FileResponse(str(src), filename=f"{base}{ext}")

backend/app/routes/plex/playlists.py

@@ -59,16 +59,12 @@ def playlists(
     group it already holds) + a top-level `group_size`, for the 'add a whole season/show' dialog."""
     contains_id = None
     if contains:
-        contains_id = db.scalar(
-            select(PlexItem.id).where(PlexItem.rating_key == str(contains))
-        )
+        contains_id = db.scalar(select(PlexItem.id).where(PlexItem.rating_key == str(contains)))
     group_ids: set[int] | None = None
     if contains_group is not None:
         rks = [s for s in (contains_group or "").split(",") if s]
         group_ids = set(
-            db.execute(
-                select(PlexItem.id).where(PlexItem.rating_key.in_(rks or [""]))
-            ).scalars()
+            db.execute(select(PlexItem.id).where(PlexItem.rating_key.in_(rks or [""]))).scalars()
         )
     out = []
     for pl in db.execute(
@@ -78,9 +74,7 @@ def playlists(
     ).scalars():
         count = (
             db.scalar(
-                select(func.count(PlexPlaylistItem.id)).where(
-                    PlexPlaylistItem.playlist_id == pl.id
-                )
+                select(func.count(PlexPlaylistItem.id)).where(PlexPlaylistItem.playlist_id == pl.id)
             )
             or 0
         )
@@ -197,9 +191,7 @@ def rename_playlist(
     db.commit()
     count = (
         db.scalar(
-            select(func.count(PlexPlaylistItem.id)).where(
-                PlexPlaylistItem.playlist_id == pl.id
-            )
+            select(func.count(PlexPlaylistItem.id)).where(PlexPlaylistItem.playlist_id == pl.id)
         )
         or 0
     )
@@ -232,20 +224,22 @@ def playlist_add_item(
     it = by_rating_key(db, PlexItem, body.item_rating_key)
     if it is None:
         raise HTTPException(status_code=404, detail="Unknown item")
-    exists = db.execute(
-        select(PlexPlaylistItem).where(
-            PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id == it.id
+    exists = (
+        db.execute(
+            select(PlexPlaylistItem).where(
+                PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id == it.id
+            )
         )
-    ).scalars().first()
+        .scalars()
+        .first()
+    )
     if exists is None:
         maxpos = db.scalar(
             select(func.coalesce(func.max(PlexPlaylistItem.position), -1)).where(
                 PlexPlaylistItem.playlist_id == pid
             )
         )
-        db.add(
-            PlexPlaylistItem(playlist_id=pid, item_id=it.id, position=int(maxpos) + 1)
-        )
+        db.add(PlexPlaylistItem(playlist_id=pid, item_id=it.id, position=int(maxpos) + 1))
         pl.updated_at = datetime.now(timezone.utc)
     db.commit()
     return {"ok": True}
@@ -282,9 +276,7 @@ def _items_by_rks(db: Session, rks: list) -> list[PlexItem]:
         return []
     by_rk = {
         it.rating_key: it
-        for it in db.execute(
-            select(PlexItem).where(PlexItem.rating_key.in_(order))
-        ).scalars()
+        for it in db.execute(select(PlexItem).where(PlexItem.rating_key.in_(order))).scalars()
     }
     seen: set[str] = set()
     out: list[PlexItem] = []
@@ -332,9 +324,7 @@ def playlist_add_bulk(
     db.commit()
     total = (
         db.scalar(
-            select(func.count(PlexPlaylistItem.id)).where(
-                PlexPlaylistItem.playlist_id == pid
-            )
+            select(func.count(PlexPlaylistItem.id)).where(PlexPlaylistItem.playlist_id == pid)
         )
         or 0
     )
@@ -365,9 +355,7 @@ def playlist_remove_bulk(
     db.commit()
     total = (
         db.scalar(
-            select(func.count(PlexPlaylistItem.id)).where(
-                PlexPlaylistItem.playlist_id == pid
-            )
+            select(func.count(PlexPlaylistItem.id)).where(PlexPlaylistItem.playlist_id == pid)
         )
         or 0
     )
@@ -395,9 +383,7 @@ def reorder_playlist(
         if iid is not None:
             db.execute(
                 update(PlexPlaylistItem)
-                .where(
-                    PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id == iid
-                )
+                .where(PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id == iid)
                 .values(position=pos)
             )
     pl.updated_at = datetime.now(timezone.utc)