4423e8464e
The adaptive genre facet always self-excluded the genre filter ({**p,"genres":
None}). That's right for "any"/OR mode — each offered genre widens the result —
but wrong for "all"/AND mode, where adding a genre narrows: it kept showing
genres that don't co-occur with the current selection, so clicking them ANDed the
result to zero (dead-end chips). Now self-exclude only in "any" mode; in "all"
mode keep the filter applied so the facet returns only genres present on the
current result set.
Guard the empty-AND case: a zero-match combination would return facets.genres=[],
and the sidebar hides the whole genre section (chips + Any/All toggle) when it's
empty — trapping the user with no per-chip way to undo the selection. Always emit
the actively-selected genres (count 0 when dropped) so they stay visible and
removable.
2110 lines
90 KiB
Python
2110 lines
90 KiB
Python
"""Plex integration API.
|
||
|
||
Read endpoints (libraries/browse/show/image) are available to ANY authenticated user (demo +
|
||
pure-Siftlode included) — the module is an access layer to the Plex library WITHOUT requiring a
|
||
plex.tv account, and playback is a local file. Admin endpoints test the connection and run the
|
||
catalog sync.
|
||
"""
|
||
import hashlib
|
||
import logging
|
||
import os
|
||
import re
|
||
import subprocess
|
||
import tempfile
|
||
import threading
|
||
import time
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
from datetime import datetime, timedelta, timezone
|
||
from pathlib import Path
|
||
from urllib.parse import quote
|
||
|
||
import httpx
|
||
from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, Request, Response
|
||
from fastapi.responses import FileResponse
|
||
from sqlalchemy import Integer, String, and_, case, cast, func, literal, null, or_
|
||
from sqlalchemy.orm import Session, aliased
|
||
|
||
from app import sysconfig
|
||
from app.auth import current_user, resolved_user_id
|
||
from app.config import settings
|
||
from app.db import SessionLocal, get_db
|
||
from app.models import (
|
||
PlexCollection,
|
||
PlexItem,
|
||
PlexLibrary,
|
||
PlexLink,
|
||
PlexPlaylist,
|
||
PlexPlaylistItem,
|
||
PlexSeason,
|
||
PlexShow,
|
||
PlexState,
|
||
User,
|
||
)
|
||
from app.plex import paths as plex_paths
|
||
from app.plex import stream as plex_stream
|
||
from app.plex import sync as plex_sync
|
||
from app.plex import watch_sync as plex_watch
|
||
from app.plex.client import PlexClient, PlexError, PlexNotConfigured
|
||
from app.routes.admin import admin_user
|
||
from app.routes.feed import _to_tsquery_str
|
||
|
||
log = logging.getLogger("siftlode.plex")
|
||
|
||
router = APIRouter(prefix="/api/plex", tags=["plex"])
|
||
|
||
_TS_CONFIG = "public.unaccent_simple"
|
||
|
||
|
||
# --- Admin: connectivity + sync ---------------------------------------------------------------
|
||
|
||
|
||
@router.post("/test")
|
||
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
|
||
surfacing as a dead player later."""
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
info = plex.server_info()
|
||
sections = plex.sections()
|
||
media_check = _media_check(db, plex, sections)
|
||
except PlexNotConfigured as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
except PlexError as e:
|
||
raise HTTPException(status_code=422, detail=f"Plex connection failed: {e}")
|
||
return {
|
||
"ok": True,
|
||
"server_name": info.get("friendlyName") or info.get("title1") or "Plex",
|
||
"version": info.get("version"),
|
||
"sections": [
|
||
{"key": str(s.get("key")), "title": s.get("title"), "type": s.get("type"), "count": s.get("count")}
|
||
for s in sections
|
||
if s.get("type") in ("movie", "show")
|
||
],
|
||
"media_check": media_check,
|
||
}
|
||
|
||
|
||
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."""
|
||
row = db.query(PlexItem.file_path).filter(PlexItem.file_path.isnot(None)).first()
|
||
if row and row[0]:
|
||
return row[0]
|
||
wanted = plex_sync._enabled_section_keys(db)
|
||
for s in sections:
|
||
if s.get("type") != "movie":
|
||
continue
|
||
key = str(s.get("key"))
|
||
if wanted is not None and key not in wanted:
|
||
continue
|
||
items, _ = plex.section_items(key, 1, 0, 1)
|
||
if items:
|
||
fp = plex_sync._media_facts(items[0]).get("file_path")
|
||
if fp:
|
||
return fp
|
||
return None
|
||
|
||
|
||
def _media_check(db: Session, plex: PlexClient, sections: list[dict]) -> dict:
|
||
"""Resolve a sample Plex file path to its local mount path and confirm it's readable, so the
|
||
admin sees at Test time whether the physical media is actually reachable (bind-mount +
|
||
path-map correct). ``checked=False`` when no sample is available (empty library)."""
|
||
plex_path = _sample_plex_path(db, plex, sections)
|
||
if not plex_path:
|
||
return {"checked": False}
|
||
local_path = plex_paths.map_path(db, plex_path)
|
||
ok = plex_paths.local_media_path(db, plex_path) is not None
|
||
return {"checked": True, "ok": ok, "plex_path": plex_path, "local_path": local_path}
|
||
|
||
|
||
@router.post("/sync")
|
||
def trigger_sync(_: User = Depends(admin_user), db: Session = Depends(get_db)) -> dict:
|
||
"""Admin: mirror the enabled Plex sections into the local catalog. Synchronous (can take a
|
||
while on a large library); a background/scheduled sync also runs periodically."""
|
||
return plex_sync.sync(db)
|
||
|
||
|
||
# --- Watch-state sync (Plex ↔ Siftlode) -------------------------------------------------------
|
||
# Phase A: the owner links their Siftlode account to the Plex admin account and does a one-time
|
||
# "Plex is master" import. Two-way push/pull lands in later phases. Admin-only for now because it
|
||
# rides the server admin token (which reads/writes the OWNER Plex account's state).
|
||
|
||
|
||
def _link_dict(link: PlexLink | None) -> dict:
|
||
return {
|
||
"linked": link is not None,
|
||
"sync_enabled": bool(link and link.sync_enabled),
|
||
"uses_admin": bool(link and link.uses_admin),
|
||
"initial_import_done": bool(link and link.initial_import_done),
|
||
"last_watch_sync_at": (
|
||
link.last_watch_sync_at.isoformat()
|
||
if link and link.last_watch_sync_at
|
||
else None
|
||
),
|
||
}
|
||
|
||
|
||
@router.get("/watch/link")
|
||
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.query(PlexLink).filter_by(user_id=user.id).first()
|
||
return _link_dict(link)
|
||
|
||
|
||
@router.post("/watch/link")
|
||
def watch_link_set(
|
||
payload: dict,
|
||
user: User = Depends(admin_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Admin: turn two-way Plex watch-sync on/off for THIS (owner) account. The link uses the server
|
||
admin token, so no separate Plex login. Enabling it for the first time runs the one-time
|
||
"Plex is master" import immediately so the owner's existing Plex history shows up in Siftlode."""
|
||
if not sysconfig.get_bool(db, "plex_enabled"):
|
||
raise HTTPException(status_code=409, detail="The Plex module is disabled.")
|
||
enabled = bool(payload.get("enabled"))
|
||
link = db.query(PlexLink).filter_by(user_id=user.id).first()
|
||
if link is None:
|
||
link = PlexLink(user_id=user.id, uses_admin=True, linked_at=datetime.now(timezone.utc))
|
||
db.add(link)
|
||
link.sync_enabled = enabled
|
||
db.commit()
|
||
|
||
result: dict = {}
|
||
if enabled and not link.initial_import_done:
|
||
result = plex_watch.import_owner_watch_state(db, link)
|
||
return {**_link_dict(link), "import": result or None}
|
||
|
||
|
||
@router.post("/watch/import")
|
||
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.query(PlexLink).filter_by(user_id=user.id).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)
|
||
return {**_link_dict(link), "import": result}
|
||
|
||
|
||
# --- Read: libraries / browse / show / image --------------------------------------------------
|
||
|
||
|
||
def _enabled() -> None:
|
||
"""Guard read endpoints when the module is off (avoids leaking a stale mirror)."""
|
||
# Read endpoints stay usable as long as a mirror exists; the toggle only gates sync + UI.
|
||
return None
|
||
|
||
|
||
@router.get("/libraries")
|
||
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)."""
|
||
libs = db.query(PlexLibrary).order_by(PlexLibrary.kind.desc(), PlexLibrary.title).all()
|
||
out = []
|
||
for lib in libs:
|
||
if lib.kind == "movie":
|
||
count = db.query(func.count(PlexItem.id)).filter_by(library_id=lib.id, kind="movie").scalar()
|
||
else:
|
||
count = db.query(func.count(PlexShow.id)).filter_by(library_id=lib.id).scalar()
|
||
out.append({"key": lib.plex_key, "title": lib.title, "kind": lib.kind, "count": count or 0})
|
||
return {"enabled": sysconfig.get_bool(db, "plex_enabled"), "libraries": out}
|
||
|
||
|
||
def _movie_card(it: PlexItem, st: PlexState | None) -> dict:
|
||
return {
|
||
"id": it.rating_key,
|
||
"type": "movie",
|
||
"title": it.title,
|
||
"year": it.year,
|
||
"duration_seconds": it.duration_s,
|
||
"thumb": f"/api/plex/image/{it.rating_key}",
|
||
"playable": it.playable,
|
||
"status": st.status if st else "new",
|
||
"position_seconds": st.position_seconds if st else 0,
|
||
}
|
||
|
||
|
||
def _show_card(sh: PlexShow, status: str = "new") -> dict:
|
||
return {
|
||
"id": sh.rating_key,
|
||
"type": "show",
|
||
"title": sh.title,
|
||
"year": sh.year,
|
||
"thumb": f"/api/plex/image/{sh.rating_key}",
|
||
"season_count": sh.child_count,
|
||
# Aggregate watch-state across the show's episodes (new | in_progress | watched) → grid badge.
|
||
"status": status,
|
||
}
|
||
|
||
|
||
def _show_status(total: int, watched: int, inprog: int) -> str:
|
||
"""Roll a show's episodes up into a single watch state: fully watched, partially started, or new."""
|
||
if total and watched >= total:
|
||
return "watched"
|
||
if (watched or 0) > 0 or (inprog or 0) > 0:
|
||
return "in_progress"
|
||
return "new"
|
||
|
||
|
||
def _rollup(cards: list[dict]) -> dict:
|
||
"""From ORDERED episode cards → the aggregate watch status, the "on deck" episode to Resume (the
|
||
last in-progress one, else the first unwatched), the first episode (for Play from the start), and
|
||
the episode count. Drives the show/season Resume + Play + mark-all buttons."""
|
||
total = len(cards)
|
||
watched = sum(1 for c in cards if c.get("status") == "watched")
|
||
inprog = [c for c in cards if (c.get("position_seconds") or 0) > 0 and c.get("status") != "watched"]
|
||
resume = None
|
||
if inprog:
|
||
resume = inprog[-1] # continue the latest-started episode
|
||
else:
|
||
resume = next((c for c in cards if c.get("status") != "watched"), None)
|
||
return {
|
||
"status": _show_status(total, watched, len(inprog)),
|
||
"resume": resume,
|
||
"first": cards[0] if cards else None,
|
||
"episode_count": total,
|
||
}
|
||
|
||
|
||
def _show_agg_subq(db: Session, user_id: int):
|
||
"""Per-show episode counts for a user: total, watched, in-progress. Reused to (a) filter the show
|
||
grid by aggregate watch-state and (b) compute each card's badge."""
|
||
ps = aliased(PlexState)
|
||
return (
|
||
db.query(
|
||
PlexItem.show_id.label("show_id"),
|
||
func.count(PlexItem.id).label("total"),
|
||
func.count(case((ps.status == "watched", 1))).label("watched"),
|
||
func.count(
|
||
case(
|
||
(
|
||
and_(ps.position_seconds > 0, or_(ps.status.is_(None), ps.status != "watched")),
|
||
1,
|
||
)
|
||
)
|
||
).label("inprog"),
|
||
)
|
||
.outerjoin(ps, and_(ps.item_id == PlexItem.id, ps.user_id == user_id))
|
||
.filter(PlexItem.kind == "episode", PlexItem.show_id.isnot(None))
|
||
.group_by(PlexItem.show_id)
|
||
)
|
||
|
||
|
||
def _show_state_map(db: Session, user_id: int, show_ids: list[int]) -> dict[int, str]:
|
||
if not show_ids:
|
||
return {}
|
||
rows = _show_agg_subq(db, user_id).filter(PlexItem.show_id.in_(show_ids)).all()
|
||
return {r.show_id: _show_status(r.total, r.watched, r.inprog) for r in rows}
|
||
|
||
|
||
def _lib_key(db: Session, library_id: int | None) -> str | None:
|
||
"""The Plex section key for a library id — the info/show page passes it to the admin collection
|
||
editor (in the unified cross-library view there's no single library prop otherwise)."""
|
||
if library_id is None:
|
||
return None
|
||
lib = db.get(PlexLibrary, library_id)
|
||
return lib.plex_key if lib else None
|
||
|
||
|
||
def _episode_card(e: PlexItem, st: PlexState | None) -> dict:
|
||
return {
|
||
"id": e.rating_key,
|
||
"type": "episode",
|
||
"title": e.title,
|
||
"summary": e.summary,
|
||
"season_number": e.season_number,
|
||
"episode_number": e.episode_number,
|
||
"duration_seconds": e.duration_s,
|
||
"thumb": f"/api/plex/image/{e.rating_key}",
|
||
"playable": e.playable,
|
||
"status": st.status if st else "new",
|
||
"position_seconds": st.position_seconds if st else 0,
|
||
}
|
||
|
||
|
||
def _leaf_card(
|
||
it: PlexItem, st: PlexState | None, show_title: str | None = None, show_rk: str | None = None
|
||
) -> dict:
|
||
"""A playable-leaf card (movie or episode). Used by playlists, which can mix both kinds.
|
||
`show_rk` (the show's rating_key) lets the client group a playlist's episodes by show/season."""
|
||
if it.kind == "episode":
|
||
card = _episode_card(it, st)
|
||
card["show_title"] = show_title
|
||
card["show_id"] = show_rk
|
||
return card
|
||
return _movie_card(it, st)
|
||
|
||
|
||
def _csv(v: str | None) -> list[str]:
|
||
return [s.strip() for s in v.split(",") if s.strip()] if v else []
|
||
|
||
|
||
_ADDED_WINDOWS = {"24h": 1, "1w": 7, "1m": 30, "6m": 182, "1y": 365}
|
||
|
||
|
||
def _added_cutoff(within: str | None) -> datetime | None:
|
||
days = _ADDED_WINDOWS.get(within or "")
|
||
return datetime.now(timezone.utc) - timedelta(days=days) if days else None
|
||
|
||
|
||
def _meta_filter_conds(model, p: dict) -> list:
|
||
"""The shared metadata-filter conditions (identical column names on plex_items + plex_shows) for
|
||
`p` (the request's filter params). Duration is movie-only, handled by the caller. Returned as a
|
||
list so faceted search can apply all-but-one group. DRY for browse, unified, and /facets."""
|
||
conds: list = []
|
||
gsel = _csv(p.get("genres"))
|
||
if gsel:
|
||
gc = [model.genres.contains([g]) for g in gsel]
|
||
conds.append(and_(*gc) if p.get("genre_mode") == "all" else or_(*gc))
|
||
crs = _csv(p.get("content_ratings"))
|
||
if crs:
|
||
conds.append(model.content_rating.in_(crs))
|
||
if p.get("year_min") is not None:
|
||
conds.append(model.year >= p["year_min"])
|
||
if p.get("year_max") is not None:
|
||
conds.append(model.year <= p["year_max"])
|
||
if p.get("rating_min") is not None:
|
||
conds.append(model.rating >= p["rating_min"])
|
||
cutoff = _added_cutoff(p.get("added_within"))
|
||
if cutoff is not None:
|
||
conds.append(model.added_at >= cutoff)
|
||
for d in _csv(p.get("directors")): # AND
|
||
conds.append(model.directors.contains([d]))
|
||
for a in _csv(p.get("actors")): # AND
|
||
conds.append(model.cast_names.contains([a]))
|
||
stds = _csv(p.get("studios"))
|
||
if stds: # OR
|
||
conds.append(model.studio.in_(stds))
|
||
if p.get("collection"):
|
||
conds.append(model.collection_keys.contains([p["collection"]]))
|
||
return conds
|
||
|
||
|
||
def _apply_meta_filters(q, model, p: dict):
|
||
conds = _meta_filter_conds(model, p)
|
||
return q.filter(*conds) if conds else q
|
||
|
||
|
||
@router.get("/library")
|
||
def unified_library(
|
||
scope: str = "both",
|
||
q: str | None = None,
|
||
sort: str = "added",
|
||
sort_dir: str = "desc",
|
||
show: str = "all",
|
||
offset: int = 0,
|
||
limit: int = Query(default=40, ge=1, le=100),
|
||
genres: str | None = None,
|
||
genre_mode: str = "any",
|
||
content_ratings: str | None = None,
|
||
year_min: int | None = None,
|
||
year_max: int | None = None,
|
||
rating_min: float | None = None,
|
||
duration_min: int | None = None,
|
||
duration_max: int | None = None,
|
||
added_within: str | None = None,
|
||
directors: str | None = None,
|
||
actors: str | None = None,
|
||
studios: str | None = None,
|
||
collection: str | None = None,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Unified cross-library browse: movies + shows in ONE mixed, paginated feed, scoped to
|
||
movie|show|both, with the shared filters/search/watch-state (a show's state is the aggregate of
|
||
its episodes). On a search that also matches episodes (and shows are in scope), the matching
|
||
episodes come back in a separate `episodes` list (grouped result — the 'Episodes' section)."""
|
||
offset = max(0, offset)
|
||
p = {
|
||
"genres": genres, "genre_mode": genre_mode, "content_ratings": content_ratings,
|
||
"year_min": year_min, "year_max": year_max, "rating_min": rating_min,
|
||
"added_within": added_within, "directors": directors, "actors": actors,
|
||
"studios": studios, "collection": collection,
|
||
}
|
||
libs = db.query(PlexLibrary).filter_by(enabled=True).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"]
|
||
want_movies = scope in ("movie", "both") and bool(movie_lib_ids)
|
||
want_shows = scope in ("show", "both") and bool(show_lib_ids)
|
||
|
||
ts = _to_tsquery_str(q) if q else None
|
||
tsq = func.to_tsquery(_TS_CONFIG, ts) if ts else None
|
||
|
||
selects = []
|
||
if want_movies:
|
||
st = aliased(PlexState)
|
||
m_status = case(
|
||
(st.status == "watched", "watched"),
|
||
(and_(st.position_seconds > 0, or_(st.status.is_(None), st.status != "watched")), "in_progress"),
|
||
else_="new",
|
||
)
|
||
mq = (
|
||
db.query(
|
||
PlexItem.rating_key.label("rk"),
|
||
literal("movie").label("kind"),
|
||
PlexItem.title.label("title"),
|
||
PlexItem.year.label("year"),
|
||
PlexItem.rating.label("rating"),
|
||
PlexItem.added_at.label("added_at"),
|
||
PlexItem.originally_available_at.label("rel"),
|
||
PlexItem.duration_s.label("duration_s"),
|
||
PlexItem.playable.label("playable"),
|
||
cast(null(), Integer).label("season_count"),
|
||
func.coalesce(st.position_seconds, 0).label("position_seconds"),
|
||
m_status.label("status"),
|
||
(func.ts_rank(PlexItem.search_vector, tsq) if tsq is not None else literal(0.0)).label("rank"),
|
||
)
|
||
.outerjoin(st, and_(st.item_id == PlexItem.id, st.user_id == user.id))
|
||
.filter(PlexItem.kind == "movie", PlexItem.library_id.in_(movie_lib_ids))
|
||
)
|
||
if show == "watched":
|
||
mq = mq.filter(st.status == "watched")
|
||
elif show == "in_progress":
|
||
mq = mq.filter(st.position_seconds > 0, or_(st.status.is_(None), st.status != "watched"))
|
||
elif show == "unwatched":
|
||
mq = mq.filter(or_(st.status.is_(None), st.status.notin_(["watched", "hidden"])))
|
||
else:
|
||
mq = mq.filter(or_(st.status.is_(None), st.status != "hidden"))
|
||
mq = _apply_meta_filters(mq, PlexItem, p)
|
||
if duration_min is not None:
|
||
mq = mq.filter(PlexItem.duration_s >= duration_min)
|
||
if duration_max is not None:
|
||
mq = mq.filter(PlexItem.duration_s <= duration_max)
|
||
if tsq is not None:
|
||
mq = mq.filter(PlexItem.search_vector.op("@@")(tsq))
|
||
selects.append(mq)
|
||
if want_shows:
|
||
agg = _show_agg_subq(db, user.id).subquery()
|
||
tot = func.coalesce(agg.c.total, 0)
|
||
wat = func.coalesce(agg.c.watched, 0)
|
||
inp = func.coalesce(agg.c.inprog, 0)
|
||
s_status = case(
|
||
(and_(tot > 0, wat >= tot), "watched"),
|
||
(or_(wat > 0, inp > 0), "in_progress"),
|
||
else_="new",
|
||
)
|
||
sq = (
|
||
db.query(
|
||
PlexShow.rating_key.label("rk"),
|
||
literal("show").label("kind"),
|
||
PlexShow.title.label("title"),
|
||
PlexShow.year.label("year"),
|
||
PlexShow.rating.label("rating"),
|
||
PlexShow.added_at.label("added_at"),
|
||
PlexShow.originally_available_at.label("rel"),
|
||
cast(null(), Integer).label("duration_s"),
|
||
cast(null(), String).label("playable"),
|
||
PlexShow.child_count.label("season_count"),
|
||
literal(0).label("position_seconds"),
|
||
s_status.label("status"),
|
||
(func.ts_rank(PlexShow.search_vector, tsq) if tsq is not None else literal(0.0)).label("rank"),
|
||
)
|
||
.outerjoin(agg, agg.c.show_id == PlexShow.id)
|
||
.filter(PlexShow.library_id.in_(show_lib_ids))
|
||
)
|
||
if show == "watched":
|
||
sq = sq.filter(tot > 0, wat >= tot)
|
||
elif show == "in_progress":
|
||
sq = sq.filter(or_(wat > 0, inp > 0), wat < tot)
|
||
elif show == "unwatched":
|
||
sq = sq.filter(wat == 0, inp == 0)
|
||
sq = _apply_meta_filters(sq, PlexShow, p)
|
||
if tsq is not None:
|
||
sq = sq.filter(PlexShow.search_vector.op("@@")(tsq))
|
||
selects.append(sq)
|
||
|
||
if not selects:
|
||
return {"scope": scope, "total": 0, "offset": offset, "limit": limit, "items": [], "episodes": []}
|
||
union = selects[0] if len(selects) == 1 else selects[0].union_all(*selects[1:])
|
||
u = union.subquery()
|
||
total = db.query(func.count()).select_from(u).scalar() or 0
|
||
|
||
if tsq is not None:
|
||
order = [u.c.rank.desc()]
|
||
else:
|
||
col = {
|
||
"title": func.lower(u.c.title),
|
||
"year": u.c.year,
|
||
"rating": u.c.rating,
|
||
"duration": u.c.duration_s,
|
||
"release": u.c.rel,
|
||
}.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.query(u).order_by(*order).offset(offset).limit(limit).all()
|
||
|
||
items = []
|
||
for r in rows:
|
||
if r.kind == "movie":
|
||
items.append({
|
||
"id": r.rk, "type": "movie", "title": r.title, "year": r.year,
|
||
"duration_seconds": r.duration_s, "thumb": f"/api/plex/image/{r.rk}",
|
||
"playable": r.playable, "status": r.status, "position_seconds": r.position_seconds,
|
||
})
|
||
else:
|
||
items.append({
|
||
"id": r.rk, "type": "show", "title": r.title, "year": r.year,
|
||
"thumb": f"/api/plex/image/{r.rk}", "season_count": r.season_count, "status": r.status,
|
||
})
|
||
|
||
episodes = []
|
||
if tsq is not None and want_shows:
|
||
ep_st = aliased(PlexState)
|
||
eps = (
|
||
db.query(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(PlexShow, PlexShow.id == PlexItem.show_id)
|
||
.filter(
|
||
PlexItem.kind == "episode",
|
||
PlexItem.library_id.in_(show_lib_ids),
|
||
PlexItem.search_vector.op("@@")(tsq),
|
||
)
|
||
.order_by(func.ts_rank(PlexItem.search_vector, tsq).desc())
|
||
.limit(24)
|
||
.all()
|
||
)
|
||
for e, s, show_title in eps:
|
||
card = _episode_card(e, s)
|
||
card["show_title"] = show_title
|
||
episodes.append(card)
|
||
|
||
return {"scope": scope, "total": total, "offset": offset, "limit": limit, "items": items, "episodes": episodes}
|
||
|
||
|
||
@router.get("/facets")
|
||
def facets(
|
||
scope: str = "both",
|
||
show: str = "all",
|
||
genres: str | None = None,
|
||
genre_mode: str = "any",
|
||
content_ratings: str | None = None,
|
||
year_min: int | None = None,
|
||
year_max: int | None = None,
|
||
rating_min: float | None = None,
|
||
duration_min: int | None = None,
|
||
duration_max: int | None = None,
|
||
added_within: str | None = None,
|
||
directors: str | None = None,
|
||
actors: str | None = None,
|
||
studios: str | None = None,
|
||
collection: str | None = None,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Available filter values for the unified library (scope movie|show|both), ADAPTED to the active
|
||
filters (faceted search): each group's values/bounds are computed with all the OTHER active
|
||
filters applied but NOT its own — so selecting a filter narrows what the other groups offer, while
|
||
a multi-select group still lets you add more. Merged across the scope's libraries; duration is
|
||
movie-only. (Search text is not factored in — facets track the sidebar filters.)"""
|
||
empty = {
|
||
"genres": [],
|
||
"content_ratings": [],
|
||
"year_min": None,
|
||
"year_max": None,
|
||
"rating_max": None,
|
||
"duration_min": None,
|
||
"duration_max": None,
|
||
}
|
||
libs = db.query(PlexLibrary).filter_by(enabled=True).all()
|
||
movie_ids = [lb.id for lb in libs if lb.kind == "movie"] if scope in ("movie", "both") else []
|
||
show_ids = [lb.id for lb in libs if lb.kind == "show"] if scope in ("show", "both") else []
|
||
if not movie_ids and not show_ids:
|
||
return empty
|
||
p = {
|
||
"genres": genres, "genre_mode": genre_mode, "content_ratings": content_ratings,
|
||
"year_min": year_min, "year_max": year_max, "rating_min": rating_min,
|
||
"duration_min": duration_min, "duration_max": duration_max, "added_within": added_within,
|
||
"directors": directors, "actors": actors, "studios": studios, "collection": collection,
|
||
}
|
||
|
||
uid = user.id
|
||
|
||
def wsq(query, model, ids, pp, kind_movie, with_dur):
|
||
"""Apply the (self-excluded) metadata filters + library scope + the per-user watch-state to a
|
||
facet aggregation query, so the facets reflect exactly the visible result set."""
|
||
query = query.filter(model.library_id.in_(ids), *_meta_filter_conds(model, pp))
|
||
if kind_movie:
|
||
query = query.filter(model.kind == "movie")
|
||
if with_dur and pp.get("duration_min") is not None:
|
||
query = query.filter(model.duration_s >= pp["duration_min"])
|
||
if with_dur and pp.get("duration_max") is not None:
|
||
query = query.filter(model.duration_s <= pp["duration_max"])
|
||
# Always join watch-state and mirror the grid's status branches (unified_library) exactly —
|
||
# hidden movies never appear in the grid, so they must not inflate facet counts/bounds either.
|
||
st = aliased(PlexState)
|
||
query = query.outerjoin(st, and_(st.item_id == model.id, st.user_id == uid))
|
||
if show == "watched":
|
||
query = query.filter(st.status == "watched")
|
||
elif show == "in_progress":
|
||
query = query.filter(st.position_seconds > 0, or_(st.status.is_(None), st.status != "watched"))
|
||
elif show == "unwatched":
|
||
query = query.filter(or_(st.status.is_(None), st.status.notin_(["watched", "hidden"])))
|
||
else:
|
||
query = query.filter(or_(st.status.is_(None), st.status != "hidden"))
|
||
else:
|
||
if show in ("watched", "in_progress", "unwatched"):
|
||
agg = _show_agg_subq(db, uid).subquery()
|
||
query = query.outerjoin(agg, agg.c.show_id == model.id)
|
||
tot = func.coalesce(agg.c.total, 0)
|
||
wat = func.coalesce(agg.c.watched, 0)
|
||
inp = func.coalesce(agg.c.inprog, 0)
|
||
if show == "watched":
|
||
query = query.filter(tot > 0, wat >= tot)
|
||
elif show == "in_progress":
|
||
query = query.filter(or_(wat > 0, inp > 0), wat < tot)
|
||
else:
|
||
query = query.filter(wat == 0, inp == 0)
|
||
return query
|
||
|
||
genre_counts: dict[str, int] = {}
|
||
cr_counts: dict[str, int] = {}
|
||
years: list[int] = []
|
||
ratings: list[float] = []
|
||
durs: list[int] = []
|
||
|
||
def per_table(model, ids, kind_movie: bool) -> None:
|
||
if not ids:
|
||
return
|
||
# Genres — in "any"/OR mode, exclude the genre filter itself so each offered genre is a valid
|
||
# OR-addition that only widens (keep adding). In "all"/AND mode, KEEP the filter applied so we
|
||
# offer only genres that CO-OCCUR on the current result set — a non-co-occurring genre would AND
|
||
# the result down to zero, i.e. a dead-end chip. (The already-selected genres still appear, since
|
||
# every matching title carries them, so they stay togglable.)
|
||
genre_pp = p if p.get("genre_mode") == "all" else {**p, "genres": None}
|
||
expanded = wsq(
|
||
db.query(func.jsonb_array_elements_text(model.genres).label("g")),
|
||
model, ids, genre_pp, kind_movie, True,
|
||
).subquery()
|
||
for g, c in db.query(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 = wsq(
|
||
db.query(model.content_rating, func.count()),
|
||
model, ids, {**p, "content_ratings": None}, kind_movie, True,
|
||
).filter(model.content_rating.isnot(None)).group_by(model.content_rating)
|
||
for cr, c in crq.all():
|
||
cr_counts[cr] = cr_counts.get(cr, 0) + c
|
||
# Year bounds — exclude the year filter.
|
||
by = wsq(
|
||
db.query(func.min(model.year), func.max(model.year)),
|
||
model, ids, {**p, "year_min": None, "year_max": None}, kind_movie, True,
|
||
).first()
|
||
if by[0] is not None:
|
||
years.append(by[0])
|
||
if by[1] is not None:
|
||
years.append(by[1])
|
||
# Rating max — exclude the rating filter.
|
||
br = wsq(db.query(func.max(model.rating)), model, ids, {**p, "rating_min": None}, kind_movie, True).scalar()
|
||
if br is not None:
|
||
ratings.append(float(br))
|
||
# Duration bounds (movies) — exclude the duration filter.
|
||
if kind_movie:
|
||
bd = wsq(
|
||
db.query(func.min(model.duration_s), func.max(model.duration_s)), model, ids, p, kind_movie, False
|
||
).first()
|
||
if bd[0] is not None:
|
||
durs.append(bd[0])
|
||
if bd[1] is not None:
|
||
durs.append(bd[1])
|
||
|
||
per_table(PlexItem, movie_ids, True)
|
||
per_table(PlexShow, show_ids, False)
|
||
# Always surface the actively-selected genres (even a zero-match AND combo, where they'd otherwise
|
||
# be absent): the sidebar renders genres solely from this list and hides the whole genre section —
|
||
# chips AND the Any/All toggle — when it's empty, which would trap the user with no per-chip way to
|
||
# undo a zero-result selection. Count 0 is fine (genre chips don't display counts).
|
||
for g in _csv(genres):
|
||
genre_counts.setdefault(g, 0)
|
||
return {
|
||
"genres": [{"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])],
|
||
"year_min": min(years) if years else None,
|
||
"year_max": max(years) if years else None,
|
||
"rating_max": max(ratings) if ratings else None,
|
||
"duration_min": min(durs) if durs else None,
|
||
"duration_max": max(durs) if durs else None,
|
||
}
|
||
|
||
|
||
def _like_escape(s: str) -> str:
|
||
return s.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
|
||
|
||
|
||
def _collection_editable(c: PlexCollection) -> bool:
|
||
"""Effective editability: the admin marked it editable AND it's a plain manual collection — never
|
||
smart, never an external auto-list (IMDb/TMDb/…), which are managed outside Plex."""
|
||
return bool(c.editable) and not c.smart and _collection_source(c) == "collection"
|
||
|
||
|
||
def _collection_card(c: PlexCollection) -> dict:
|
||
return {
|
||
"id": c.rating_key,
|
||
"title": c.title,
|
||
"summary": c.summary,
|
||
"thumb": f"/api/plex/image/{c.rating_key}" if c.thumb_key else None,
|
||
"child_count": c.child_count,
|
||
"smart": c.smart,
|
||
"source": _collection_source(c),
|
||
"editable": c.editable,
|
||
"can_edit": _collection_editable(c), # whether the edit controls should be offered (admin UI)
|
||
}
|
||
|
||
|
||
@router.get("/collections")
|
||
def collections(
|
||
library: str | None = None,
|
||
q: str | None = None,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Mirrored collections as cards (most-populated first), optionally name-filtered by `q`. With a
|
||
`library` plex_key → that one library's collections (used by the collection editor). WITHOUT one →
|
||
the UNION across all enabled libraries (the unified-scope sidebar picker, which has no single
|
||
library selected)."""
|
||
if library is not None:
|
||
lib = db.query(PlexLibrary).filter_by(plex_key=str(library)).first()
|
||
if lib is None:
|
||
return {"collections": []}
|
||
query = db.query(PlexCollection).filter(PlexCollection.library_id == lib.id)
|
||
else:
|
||
enabled_ids = [lb.id for lb in db.query(PlexLibrary.id).filter_by(enabled=True)]
|
||
if not enabled_ids:
|
||
return {"collections": []}
|
||
query = db.query(PlexCollection).filter(PlexCollection.library_id.in_(enabled_ids))
|
||
term = (q or "").strip()
|
||
if term:
|
||
query = query.filter(PlexCollection.title.ilike(f"%{_like_escape(term)}%"))
|
||
rows = query.order_by(
|
||
PlexCollection.child_count.desc().nullslast(), func.lower(PlexCollection.title)
|
||
).all()
|
||
return {"collections": [_collection_card(c) for c in rows]}
|
||
|
||
|
||
# --- Collection editing (P2, admin-only — writes back to Plex; changes are shared across all clients).
|
||
def _editable_collection_or_403(db: Session, rating_key: str) -> PlexCollection:
|
||
col = db.query(PlexCollection).filter_by(rating_key=str(rating_key)).first()
|
||
if col is None:
|
||
raise HTTPException(status_code=404, detail="Unknown collection")
|
||
if not _collection_editable(col):
|
||
raise HTTPException(status_code=403, detail="This collection is read-only")
|
||
return col
|
||
|
||
|
||
@router.post("/collections")
|
||
def create_collection(payload: dict, _: User = Depends(admin_user), db: Session = Depends(get_db)) -> dict:
|
||
"""Create a manual collection (seeded with one item — Plex needs at least one). Editable by default."""
|
||
library = str(payload.get("library") or "")
|
||
title = (payload.get("title") or "").strip()
|
||
seed = str(payload.get("item_rating_key") or "")
|
||
if not title or not seed:
|
||
raise HTTPException(status_code=422, detail="title and item_rating_key are required")
|
||
lib = db.query(PlexLibrary).filter_by(plex_key=library).first()
|
||
if lib is None:
|
||
raise HTTPException(status_code=404, detail="Unknown library")
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
new = plex.create_collection(lib.plex_key, title, seed)
|
||
col = plex_sync.resync_collection(db, plex, lib, str(new.get("ratingKey")))
|
||
col.editable = True
|
||
db.commit()
|
||
except (PlexError, PlexNotConfigured) as e:
|
||
db.rollback()
|
||
raise HTTPException(status_code=502, detail=f"Plex write failed: {e}")
|
||
return _collection_card(col)
|
||
|
||
|
||
@router.post("/collections/{rating_key}/items/{item_rating_key}")
|
||
def collection_add_item(
|
||
rating_key: str, item_rating_key: str, _: User = Depends(admin_user), db: Session = Depends(get_db)
|
||
) -> dict:
|
||
col = _editable_collection_or_403(db, rating_key)
|
||
lib = db.get(PlexLibrary, col.library_id)
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
plex.add_collection_item(rating_key, str(item_rating_key))
|
||
col = plex_sync.resync_collection(db, plex, lib, rating_key)
|
||
db.commit()
|
||
except (PlexError, PlexNotConfigured) as e:
|
||
db.rollback()
|
||
raise HTTPException(status_code=502, detail=f"Plex write failed: {e}")
|
||
return _collection_card(col)
|
||
|
||
|
||
@router.delete("/collections/{rating_key}/items/{item_rating_key}")
|
||
def collection_remove_item(
|
||
rating_key: str, item_rating_key: str, _: User = Depends(admin_user), db: Session = Depends(get_db)
|
||
) -> dict:
|
||
col = _editable_collection_or_403(db, rating_key)
|
||
lib = db.get(PlexLibrary, col.library_id)
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
plex.remove_collection_item(rating_key, str(item_rating_key))
|
||
col = plex_sync.resync_collection(db, plex, lib, rating_key)
|
||
db.commit()
|
||
except (PlexError, PlexNotConfigured) as e:
|
||
db.rollback()
|
||
raise HTTPException(status_code=502, detail=f"Plex write failed: {e}")
|
||
return _collection_card(col)
|
||
|
||
|
||
@router.patch("/collections/{rating_key}")
|
||
def collection_rename(
|
||
rating_key: str, payload: dict, _: User = Depends(admin_user), db: Session = Depends(get_db)
|
||
) -> dict:
|
||
col = _editable_collection_or_403(db, rating_key)
|
||
title = (payload.get("title") or "").strip()
|
||
if not title:
|
||
raise HTTPException(status_code=422, detail="title is required")
|
||
lib = db.get(PlexLibrary, col.library_id)
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
plex.rename_collection(lib.plex_key, rating_key, title)
|
||
col = plex_sync.resync_collection(db, plex, lib, rating_key)
|
||
db.commit()
|
||
except (PlexError, PlexNotConfigured) as e:
|
||
db.rollback()
|
||
raise HTTPException(status_code=502, detail=f"Plex write failed: {e}")
|
||
return _collection_card(col)
|
||
|
||
|
||
@router.delete("/collections/{rating_key}")
|
||
def collection_delete(
|
||
rating_key: str, _: User = Depends(admin_user), db: Session = Depends(get_db)
|
||
) -> dict:
|
||
col = _editable_collection_or_403(db, rating_key)
|
||
lib = db.get(PlexLibrary, col.library_id)
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
plex.delete_collection(rating_key)
|
||
plex_sync.delete_collection_local(db, lib, rating_key)
|
||
db.commit()
|
||
except (PlexError, PlexNotConfigured) as e:
|
||
db.rollback()
|
||
raise HTTPException(status_code=502, detail=f"Plex write failed: {e}")
|
||
return {"deleted": rating_key}
|
||
|
||
|
||
@router.post("/collections/{rating_key}/editable")
|
||
def collection_set_editable(
|
||
rating_key: str, payload: dict, _: User = Depends(admin_user), db: Session = Depends(get_db)
|
||
) -> dict:
|
||
"""Mark an existing Plex collection as 'mine to edit' (or unmark). Smart / auto-list collections
|
||
(IMDb/TMDb/…) can never be made editable — they're regenerated outside Plex."""
|
||
col = db.query(PlexCollection).filter_by(rating_key=str(rating_key)).first()
|
||
if col is None:
|
||
raise HTTPException(status_code=404, detail="Unknown collection")
|
||
want = bool(payload.get("editable"))
|
||
if want and (col.smart or _collection_source(col) != "collection"):
|
||
raise HTTPException(status_code=400, detail="Smart / auto-list collections can't be made editable")
|
||
col.editable = want
|
||
db.commit()
|
||
return _collection_card(col)
|
||
|
||
|
||
# --- Playlists (Siftlode-native, per-user, ordered — no Plex account needed; Plex sync is a later phase).
|
||
def _own_playlist_or_404(db: Session, pid: int, user: User) -> PlexPlaylist:
|
||
pl = db.query(PlexPlaylist).filter_by(id=pid, user_id=user.id).first()
|
||
if pl is None:
|
||
raise HTTPException(status_code=404, detail="Playlist not found")
|
||
return pl
|
||
|
||
|
||
def _playlist_card(pl: PlexPlaylist, count: int, thumb_rk: str | None) -> dict:
|
||
return {
|
||
"id": pl.id,
|
||
"title": pl.title,
|
||
"item_count": count,
|
||
"thumb": f"/api/plex/image/{thumb_rk}" if thumb_rk else None,
|
||
}
|
||
|
||
|
||
def _playlist_item_query(db: Session, pid: int):
|
||
return (
|
||
db.query(PlexPlaylistItem, PlexItem)
|
||
.join(PlexItem, PlexItem.id == PlexPlaylistItem.item_id)
|
||
.filter(PlexPlaylistItem.playlist_id == pid)
|
||
.order_by(PlexPlaylistItem.position, PlexPlaylistItem.id)
|
||
)
|
||
|
||
|
||
@router.get("/playlists")
|
||
def playlists(
|
||
contains: str | None = None,
|
||
contains_group: str | None = None,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""The current user's playlists (newest-touched first), each with an item count + a cover thumb.
|
||
`contains`=an item rating_key adds `has_item` per playlist (for the single 'add to playlist' dialog).
|
||
`contains_group`=a comma-separated list of rating_keys adds `group_in` per playlist (how many of the
|
||
group it already holds) + a top-level `group_size`, for the 'add a whole season/show' dialog."""
|
||
contains_id = None
|
||
if contains:
|
||
row = db.query(PlexItem.id).filter_by(rating_key=str(contains)).first()
|
||
contains_id = row[0] if row else None
|
||
group_ids: set[int] | None = None
|
||
if contains_group is not None:
|
||
rks = [s for s in (contains_group or "").split(",") if s]
|
||
rows = db.query(PlexItem.id).filter(PlexItem.rating_key.in_(rks or [""])).all()
|
||
group_ids = {r[0] for r in rows}
|
||
out = []
|
||
for pl in db.query(PlexPlaylist).filter_by(user_id=user.id).order_by(PlexPlaylist.updated_at.desc()):
|
||
count = db.query(func.count(PlexPlaylistItem.id)).filter_by(playlist_id=pl.id).scalar() or 0
|
||
first = _playlist_item_query(db, pl.id).first()
|
||
card = _playlist_card(pl, count, first[1].rating_key if first else None)
|
||
if contains_id is not None:
|
||
card["has_item"] = (
|
||
db.query(PlexPlaylistItem.id).filter_by(playlist_id=pl.id, item_id=contains_id).first()
|
||
is not None
|
||
)
|
||
if group_ids is not None:
|
||
card["group_in"] = (
|
||
db.query(func.count(PlexPlaylistItem.id))
|
||
.filter(PlexPlaylistItem.playlist_id == pl.id, PlexPlaylistItem.item_id.in_(group_ids or [0]))
|
||
.scalar()
|
||
or 0
|
||
)
|
||
out.append(card)
|
||
resp: dict = {"playlists": out}
|
||
if group_ids is not None:
|
||
resp["group_size"] = len(group_ids)
|
||
return resp
|
||
|
||
|
||
@router.post("/playlists")
|
||
def create_playlist(payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
title = (payload.get("title") or "").strip()
|
||
if not title:
|
||
raise HTTPException(status_code=422, detail="title is required")
|
||
pl = PlexPlaylist(user_id=user.id, title=title)
|
||
db.add(pl)
|
||
db.flush()
|
||
seed = str(payload.get("item_rating_key") or "")
|
||
count = 0
|
||
thumb_rk = None
|
||
if seed:
|
||
it = db.query(PlexItem).filter_by(rating_key=seed).first()
|
||
if it is not None:
|
||
db.add(PlexPlaylistItem(playlist_id=pl.id, item_id=it.id, position=0))
|
||
count, thumb_rk = 1, it.rating_key
|
||
db.commit()
|
||
return _playlist_card(pl, count, thumb_rk)
|
||
|
||
|
||
@router.get("/playlists/{pid}")
|
||
def playlist_detail(pid: int, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
rows = _playlist_item_query(db, pid).all()
|
||
items = [it for (_pi, it) in rows]
|
||
states = {
|
||
s.item_id: s
|
||
for s in db.query(PlexState).filter(
|
||
PlexState.user_id == user.id, PlexState.item_id.in_([it.id for it in items] or [0])
|
||
)
|
||
}
|
||
shows = {
|
||
sh.id: sh
|
||
for sh in db.query(PlexShow).filter(PlexShow.id.in_([it.show_id for it in items if it.show_id] or [0]))
|
||
}
|
||
cards = [
|
||
_leaf_card(
|
||
it,
|
||
states.get(it.id),
|
||
shows[it.show_id].title if it.show_id in shows else None,
|
||
shows[it.show_id].rating_key if it.show_id in shows else None,
|
||
)
|
||
for it in items
|
||
]
|
||
return {"id": pl.id, "title": pl.title, "items": cards}
|
||
|
||
|
||
@router.patch("/playlists/{pid}")
|
||
def rename_playlist(pid: int, payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
title = (payload.get("title") or "").strip()
|
||
if not title:
|
||
raise HTTPException(status_code=422, detail="title is required")
|
||
pl.title = title
|
||
db.commit()
|
||
count = db.query(func.count(PlexPlaylistItem.id)).filter_by(playlist_id=pl.id).scalar() or 0
|
||
first = _playlist_item_query(db, pl.id).first()
|
||
return _playlist_card(pl, count, first[1].rating_key if first else None)
|
||
|
||
|
||
@router.delete("/playlists/{pid}")
|
||
def delete_playlist(pid: int, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
db.delete(pl)
|
||
db.commit()
|
||
return {"deleted": pid}
|
||
|
||
|
||
@router.post("/playlists/{pid}/items")
|
||
def playlist_add_item(pid: int, payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
it = db.query(PlexItem).filter_by(rating_key=str(payload.get("item_rating_key") or "")).first()
|
||
if it is None:
|
||
raise HTTPException(status_code=404, detail="Unknown item")
|
||
exists = db.query(PlexPlaylistItem).filter_by(playlist_id=pid, item_id=it.id).first()
|
||
if exists is None:
|
||
maxpos = db.query(func.coalesce(func.max(PlexPlaylistItem.position), -1)).filter_by(playlist_id=pid).scalar()
|
||
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}
|
||
|
||
|
||
@router.delete("/playlists/{pid}/items/{item_rating_key}")
|
||
def playlist_remove_item(pid: int, item_rating_key: str, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
it = db.query(PlexItem).filter_by(rating_key=str(item_rating_key)).first()
|
||
if it is not None:
|
||
db.query(PlexPlaylistItem).filter_by(playlist_id=pid, item_id=it.id).delete()
|
||
pl.updated_at = datetime.now(timezone.utc)
|
||
db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
def _items_by_rks(db: Session, rks: list) -> list[PlexItem]:
|
||
"""Resolve rating_keys to PlexItems, preserving the input order (drops unknown keys)."""
|
||
order = [str(k) for k in rks if str(k)]
|
||
if not order:
|
||
return []
|
||
by_rk = {it.rating_key: it for it in db.query(PlexItem).filter(PlexItem.rating_key.in_(order))}
|
||
seen: set[str] = set()
|
||
out: list[PlexItem] = []
|
||
for rk in order:
|
||
it = by_rk.get(rk)
|
||
if it is not None and rk not in seen:
|
||
seen.add(rk)
|
||
out.append(it)
|
||
return out
|
||
|
||
|
||
@router.post("/playlists/{pid}/items/bulk")
|
||
def playlist_add_bulk(pid: int, payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
"""Append many items at once (a whole season/show). Already-present items are skipped; the input
|
||
order is preserved for the newly-added ones. Returns how many were added + the new total."""
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
items = _items_by_rks(db, payload.get("item_rating_keys") or [])
|
||
existing = {row[0] for row in db.query(PlexPlaylistItem.item_id).filter_by(playlist_id=pid)}
|
||
pos = int(db.query(func.coalesce(func.max(PlexPlaylistItem.position), -1)).filter_by(playlist_id=pid).scalar())
|
||
added = 0
|
||
for it in items:
|
||
if it.id in existing:
|
||
continue
|
||
pos += 1
|
||
db.add(PlexPlaylistItem(playlist_id=pid, item_id=it.id, position=pos))
|
||
existing.add(it.id)
|
||
added += 1
|
||
if added:
|
||
pl.updated_at = datetime.now(timezone.utc)
|
||
db.commit()
|
||
total = db.query(func.count(PlexPlaylistItem.id)).filter_by(playlist_id=pid).scalar() or 0
|
||
return {"added": added, "item_count": total}
|
||
|
||
|
||
@router.post("/playlists/{pid}/items/remove-bulk")
|
||
def playlist_remove_bulk(pid: int, payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
"""Remove many items at once (a whole season/show, or a multi-select). Returns how many were
|
||
removed + the new total."""
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
ids = [it.id for it in _items_by_rks(db, payload.get("item_rating_keys") or [])]
|
||
removed = 0
|
||
if ids:
|
||
removed = (
|
||
db.query(PlexPlaylistItem)
|
||
.filter(PlexPlaylistItem.playlist_id == pid, PlexPlaylistItem.item_id.in_(ids))
|
||
.delete(synchronize_session=False)
|
||
)
|
||
if removed:
|
||
pl.updated_at = datetime.now(timezone.utc)
|
||
db.commit()
|
||
total = db.query(func.count(PlexPlaylistItem.id)).filter_by(playlist_id=pid).scalar() or 0
|
||
return {"removed": removed, "item_count": total}
|
||
|
||
|
||
@router.put("/playlists/{pid}/order")
|
||
def reorder_playlist(pid: int, payload: dict, user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
|
||
"""Set the playlist order from an explicit list of item rating_keys (0-based positions)."""
|
||
pl = _own_playlist_or_404(db, pid, user)
|
||
order = [str(k) for k in (payload.get("item_rating_keys") or [])]
|
||
id_by_rk = {it.rating_key: it.id for it in db.query(PlexItem).filter(PlexItem.rating_key.in_(order or [""]))}
|
||
for pos, rk in enumerate(order):
|
||
iid = id_by_rk.get(rk)
|
||
if iid is not None:
|
||
db.query(PlexPlaylistItem).filter_by(playlist_id=pid, item_id=iid).update({"position": pos})
|
||
pl.updated_at = datetime.now(timezone.utc)
|
||
db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
# Live-Plex enrichment for a show (cast/IMDb + related) is user-independent raw payload, so it's cached
|
||
# per rating_key for a short TTL and shared across users; per-user shaping happens in the caller. Bounds
|
||
# staleness to the TTL while turning repeat opens of the same show into zero network calls.
|
||
_SHOW_ENRICH_TTL_S = 300
|
||
_show_enrich_cache: dict[str, tuple[float, dict, list]] = {}
|
||
_show_enrich_lock = threading.Lock()
|
||
|
||
|
||
def _show_enrichment(db: Session, rating_key: str) -> tuple[dict, list]:
|
||
"""(meta, related_raw) for a show's live Plex enrichment — served from the per-show TTL cache when
|
||
warm, otherwise fetched with the two Plex calls (metadata + related) run IN PARALLEL. Returns
|
||
({}, []) when Plex is unavailable/unconfigured (not cached, so it retries on the next open)."""
|
||
now = time.monotonic()
|
||
with _show_enrich_lock:
|
||
hit = _show_enrich_cache.get(rating_key)
|
||
if hit is not None and hit[0] > now:
|
||
return hit[1], hit[2]
|
||
try:
|
||
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 → []
|
||
meta = meta_f.result() or {}
|
||
related_raw = related_f.result()
|
||
except (PlexError, PlexNotConfigured):
|
||
return {}, []
|
||
# Don't cache an EMPTY related list: plex.related() swallows a transient failure as [] (same as a
|
||
# genuinely no-related show), so caching it would serve an empty "related" section for the whole TTL
|
||
# even after Plex recovers. Skip the cache in that case (retry next open, as before); shows that DO
|
||
# have related items — the payload worth caching — still get cached.
|
||
if related_raw:
|
||
with _show_enrich_lock:
|
||
_show_enrich_cache[rating_key] = (now + _SHOW_ENRICH_TTL_S, meta, related_raw)
|
||
return meta, related_raw
|
||
|
||
|
||
@router.get("/show/{rating_key}")
|
||
def show_detail(
|
||
rating_key: str,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""A show's seasons + episodes (the drill-down view) with per-user watch state."""
|
||
sh = db.query(PlexShow).filter_by(rating_key=str(rating_key)).first()
|
||
if sh is None:
|
||
raise HTTPException(status_code=404, detail="Unknown Plex show")
|
||
seasons = (
|
||
db.query(PlexSeason).filter_by(show_id=sh.id).order_by(PlexSeason.season_number.asc().nullsfirst()).all()
|
||
)
|
||
eps = (
|
||
db.query(PlexItem)
|
||
.filter_by(show_id=sh.id, kind="episode")
|
||
.order_by(PlexItem.season_number.asc().nullsfirst(), PlexItem.episode_number.asc().nullsfirst())
|
||
.all()
|
||
)
|
||
states = {
|
||
s.item_id: s
|
||
for s in db.query(PlexState).filter(
|
||
PlexState.user_id == user.id, PlexState.item_id.in_([e.id for e in eps] or [0])
|
||
)
|
||
}
|
||
by_season: dict[int | None, list] = {}
|
||
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)
|
||
all_cards.append(card)
|
||
show_roll = _rollup(all_cards)
|
||
|
||
# Cast + IMDb (best-effort live metadata; same shape as the movie/episode info page). The two live
|
||
# Plex calls are cached per-show + fetched in parallel by _show_enrichment; the per-user shaping
|
||
# (_related_show_cards adds this user's watch-state) stays out of the shared cache.
|
||
rich: dict = {}
|
||
related: list[dict] = []
|
||
try:
|
||
meta, related_raw = _show_enrichment(db, sh.rating_key)
|
||
rich = _rich_meta(meta)
|
||
related = _related_show_cards(db, user.id, related_raw, exclude=sh.id)
|
||
except Exception:
|
||
# Best-effort enrichment only — the local episode list is already assembled, so any live-Plex
|
||
# failure (not configured, HTTP/JSON shape, _rich_meta parse error) must degrade, not 500.
|
||
pass
|
||
|
||
return {
|
||
"show": {
|
||
"id": sh.rating_key,
|
||
"title": sh.title,
|
||
"summary": sh.summary,
|
||
"year": sh.year,
|
||
"thumb": f"/api/plex/image/{sh.rating_key}",
|
||
"art": f"/api/plex/image/{sh.rating_key}?variant=art",
|
||
"library": _lib_key(db, sh.library_id),
|
||
"content_rating": sh.content_rating,
|
||
"rating": sh.rating,
|
||
"genres": sh.genres or [],
|
||
"studio": sh.studio,
|
||
"season_count": sh.child_count,
|
||
"imdb_rating": rich.get("imdb_rating"),
|
||
"imdb_id": rich.get("imdb_id"),
|
||
"imdb_url": rich.get("imdb_url"),
|
||
"cast": rich.get("cast", []),
|
||
# Show-level rollup for the hero action buttons.
|
||
"status": show_roll["status"],
|
||
"resume": show_roll["resume"],
|
||
"first": show_roll["first"],
|
||
"episode_count": show_roll["episode_count"],
|
||
"collection_keys": sh.collection_keys or [],
|
||
},
|
||
"seasons": [
|
||
_season_block(se, by_season.get(se.id, []))
|
||
for se in seasons
|
||
],
|
||
"related": related,
|
||
}
|
||
|
||
|
||
def _season_block(se: PlexSeason, cards: list[dict]) -> dict:
|
||
"""A season's card for the show page (with its aggregate rollup) plus its episodes (used by the
|
||
season subpage, read from the same cached show-detail payload)."""
|
||
roll = _rollup(cards)
|
||
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"),
|
||
"thumb": f"/api/plex/image/{se.rating_key}",
|
||
"episode_count": roll["episode_count"],
|
||
"status": roll["status"],
|
||
"resume": roll["resume"],
|
||
"first": roll["first"],
|
||
"episodes": cards,
|
||
}
|
||
|
||
|
||
def _related_show_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")]
|
||
if not rks:
|
||
return []
|
||
shows = {
|
||
s.rating_key: s
|
||
for s in db.query(PlexShow).filter(PlexShow.rating_key.in_(rks[:60]), PlexShow.id != exclude)
|
||
}
|
||
statuses = _show_state_map(db, user_id, [s.id for s in shows.values()])
|
||
out: list[dict] = []
|
||
seen: set[str] = set()
|
||
for rk in rks:
|
||
sh = shows.get(rk)
|
||
if sh is None or rk in seen:
|
||
continue
|
||
seen.add(rk)
|
||
out.append(_show_card(sh, statuses.get(sh.id, "new")))
|
||
if len(out) >= 20:
|
||
break
|
||
return out
|
||
|
||
|
||
def _image_key(db: Session, rating_key: str, variant: str) -> str | None:
|
||
"""The stored Plex image path for a known rating_key (item/show/season). Only mirrored keys
|
||
are proxyable — this is not an open image proxy."""
|
||
it = db.query(PlexItem).filter_by(rating_key=rating_key).first()
|
||
if it is not None:
|
||
return it.art_key if variant == "art" else it.thumb_key
|
||
sh = db.query(PlexShow).filter_by(rating_key=rating_key).first()
|
||
if sh is not None:
|
||
return sh.art_key if variant == "art" else sh.thumb_key
|
||
se = db.query(PlexSeason).filter_by(rating_key=rating_key).first()
|
||
if se is not None:
|
||
return se.thumb_key
|
||
col = db.query(PlexCollection).filter_by(rating_key=rating_key).first()
|
||
if col is not None:
|
||
return col.thumb_key
|
||
return None
|
||
|
||
|
||
# --- Thin on-disk image cache -----------------------------------------------------------------
|
||
# Posters/art/cast-photos are proxied on demand; without a cache every scroll re-hits Plex over the
|
||
# LAN (janky). We cache the fetched bytes on local disk keyed by a stable id, so repeat views (and
|
||
# other users) serve instantly from disk. On-demand + bounded by the library size; no eviction (a
|
||
# few hundred MB at most for a big library — acceptable, matching the download disk trade-offs).
|
||
_IMG_CACHE = Path(settings.download_root) / ".plex-img-cache"
|
||
_EXT_CT = [("jpg", "image/jpeg"), ("png", "image/png"), ("webp", "image/webp")]
|
||
_CT_EXT = {ct: ext for ext, ct in _EXT_CT}
|
||
# Target box per variant — Plex resizes to these server-side. Posters fill ≤176px cells (grid/info/
|
||
# strips), so 400px covers 2× DPR; the faint backdrop art only needs ~1280px. Keeps images ~tens of KB.
|
||
_IMG_SIZES = {"thumb": (400, 600), "art": (1280, 720)}
|
||
|
||
# Image-based subtitle codecs (Blu-ray/DVD) — can't be turned into text WebVTT (would need burn-in).
|
||
_BITMAP_SUBS = {"pgs", "hdmv_pgs_subtitle", "dvd_subtitle", "dvdsub", "vobsub", "dvbsub", "dvb_subtitle"}
|
||
|
||
|
||
def _srt_to_vtt(text: str) -> str:
|
||
"""Minimal SubRip→WebVTT: add the header and switch the ms separator (`,`→`.`). SRT cue-index
|
||
lines are valid in WebVTT, so they're left as-is."""
|
||
body = re.sub(r"(\d\d:\d\d:\d\d),(\d\d\d)", r"\1.\2", text.replace("\r\n", "\n").lstrip(""))
|
||
return "WEBVTT\n\n" + body.strip() + "\n"
|
||
|
||
|
||
def _vtt_ts_to_s(ts: str) -> float:
|
||
parts = ts.split(":")
|
||
h = "0" if len(parts) == 2 else parts[0]
|
||
m, rest = parts[-2], parts[-1]
|
||
sec, _, ms = rest.partition(".")
|
||
return int(h) * 3600 + int(m) * 60 + int(sec) + int(ms or 0) / 1000.0
|
||
|
||
|
||
def _vtt_s_to_ts(x: float) -> str:
|
||
x = max(0.0, x)
|
||
h = int(x // 3600); x -= h * 3600
|
||
m = int(x // 60); x -= m * 60
|
||
s = int(x); ms = int(round((x - s) * 1000))
|
||
if ms >= 1000:
|
||
s += 1; ms -= 1000
|
||
return f"{h:02d}:{m:02d}:{s:02d}.{ms:03d}"
|
||
|
||
|
||
def _shift_vtt(vtt: str, offset: float) -> str:
|
||
"""Subtract `offset` seconds from every cue's start/end. WebVTT cues carry ABSOLUTE content times,
|
||
but an HLS remux session's clock is zero-based at the real keyframe (see stream.py media_start_s),
|
||
so a subtitle overlaid on that session must be shifted by that offset to line up with speech.
|
||
|
||
Processes cue BLOCKS so a cue that shifts fully into the past (end <= 0) can be DROPPED entirely.
|
||
(Collapsing them to 00:00:00.000-->00:00:00.000 made EVERY past cue count as active at currentTime 0
|
||
— where a resume/seek lands — piling all of them on screen until playback advanced past 0.) A cue
|
||
straddling 0 is clamped to start at 0."""
|
||
if not offset:
|
||
return vtt
|
||
out_blocks: list[str] = []
|
||
for block in re.split(r"\n[ \t]*\n", vtt):
|
||
if "-->" not in block:
|
||
out_blocks.append(block) # header / NOTE / STYLE — keep verbatim
|
||
continue
|
||
lines = block.split("\n")
|
||
keep = True
|
||
for i, ln in enumerate(lines):
|
||
if "-->" not in ln:
|
||
continue
|
||
left, _, right = ln.partition("-->")
|
||
rparts = right.strip().split(None, 1)
|
||
settings = (" " + rparts[1]) if len(rparts) > 1 else ""
|
||
try:
|
||
st = _vtt_ts_to_s(left.strip()) - offset
|
||
en = _vtt_ts_to_s(rparts[0]) - offset
|
||
except (ValueError, IndexError):
|
||
break # unparseable timing → leave the block as-is
|
||
if en <= 0:
|
||
keep = False # whole cue is before the session start → drop the block
|
||
else:
|
||
lines[i] = f"{_vtt_s_to_ts(st)} --> {_vtt_s_to_ts(en)}{settings}" # _vtt_s_to_ts clamps st>=0
|
||
break
|
||
if keep:
|
||
out_blocks.append("\n".join(lines))
|
||
return "\n\n".join(out_blocks)
|
||
|
||
|
||
def _ffmpeg_to_vtt(src: str, sub_ord: int | None) -> str:
|
||
"""Convert one subtitle stream of a file to WebVTT via ffmpeg (for embedded subs, and non-SRT
|
||
external subs written to a temp file). `sub_ord` = ordinal among the file's subtitle streams."""
|
||
cmd = ["ffmpeg", "-nostdin", "-loglevel", "error", "-i", src,
|
||
"-map", f"0:s:{sub_ord if sub_ord is not None else 0}", "-f", "webvtt", "pipe:1"]
|
||
r = subprocess.run(cmd, capture_output=True)
|
||
if r.returncode != 0 or not r.stdout:
|
||
raise PlexError((r.stderr or b"").decode("utf-8", "replace")[:200] or "ffmpeg subtitle convert failed")
|
||
return r.stdout.decode("utf-8", "replace")
|
||
|
||
|
||
def _sub_cache_read(key: str) -> str | None:
|
||
try:
|
||
p = _IMG_CACHE / f"{key}.vtt"
|
||
return p.read_text(encoding="utf-8") if p.exists() else None
|
||
except OSError:
|
||
return None
|
||
|
||
|
||
def _sub_cache_write(key: str, vtt: str) -> None:
|
||
try:
|
||
_IMG_CACHE.mkdir(parents=True, exist_ok=True)
|
||
tmp = _IMG_CACHE / f"{key}.vtt.tmp"
|
||
tmp.write_text(vtt, encoding="utf-8")
|
||
tmp.replace(_IMG_CACHE / f"{key}.vtt") # atomic publish
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def _img_cache_read(key: str) -> tuple[bytes, str] | None:
|
||
for ext, ct in _EXT_CT:
|
||
p = _IMG_CACHE / f"{key}.{ext}"
|
||
try:
|
||
if p.exists() and p.stat().st_size > 0:
|
||
return p.read_bytes(), ct
|
||
except OSError:
|
||
pass
|
||
return None
|
||
|
||
|
||
def _img_cache_write(key: str, data: bytes, ct: str) -> None:
|
||
ext = _CT_EXT.get((ct or "").split(";")[0].strip(), "jpg")
|
||
try:
|
||
_IMG_CACHE.mkdir(parents=True, exist_ok=True)
|
||
tmp = _IMG_CACHE / f"{key}.{ext}.tmp"
|
||
tmp.write_bytes(data)
|
||
tmp.replace(_IMG_CACHE / f"{key}.{ext}") # atomic publish
|
||
except OSError:
|
||
pass # cache is best-effort
|
||
|
||
|
||
def _img_response(data: bytes, ct: str) -> Response:
|
||
return Response(content=data, media_type=ct, headers={"Cache-Control": "public, max-age=86400"})
|
||
|
||
|
||
def _require_session(request: Request) -> int:
|
||
"""Lightweight auth for the high-fan-out image proxies: validate the signed session cookie WITHOUT
|
||
a DB user-load, so these endpoints never hold a pool connection for the auth. Poster images are
|
||
low-sensitivity; a valid session is enough."""
|
||
uid, _ = resolved_user_id(request)
|
||
if not uid:
|
||
raise HTTPException(status_code=401, detail="Not authenticated")
|
||
return uid
|
||
|
||
|
||
@router.get("/image/{rating_key}")
|
||
def image(rating_key: str, request: Request, variant: str = "thumb") -> Response:
|
||
"""Proxy a Plex poster/art image (keeps the admin token server-side; no image duplication). A
|
||
thin on-disk cache serves repeat views without re-hitting Plex.
|
||
|
||
⚠️ This endpoint is called in BURSTS (a collections page fires 100+ concurrent poster requests),
|
||
so it must NOT hold a DB connection during the slow Plex fetch — doing so exhausted the pool
|
||
(QueuePool timeout, broken images on prod). Warm path (cache hit) touches NO DB; cold path opens a
|
||
brief session only to resolve the image key + read the Plex config, then RELEASES it before the
|
||
fetch. Auth is the signed-session check (no DB user-load)."""
|
||
_require_session(request)
|
||
v = "art" if variant == "art" else "thumb"
|
||
w, h = _IMG_SIZES[v]
|
||
# Size is part of the cache key: Plex resizes server-side (see PlexClient.image_bytes), so we cache
|
||
# the small variant. The width tag also means changing a target size just re-caches, never serves a
|
||
# stale differently-sized file (old full-size files under the un-tagged key are simply orphaned).
|
||
cache_key = f"item_{rating_key}_{v}_{w}"
|
||
hit = _img_cache_read(cache_key)
|
||
if hit:
|
||
return _img_response(*hit)
|
||
# Cold miss: short-lived session for the key + Plex client config, released before the slow fetch.
|
||
try:
|
||
with SessionLocal() as db:
|
||
key = _image_key(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
|
||
except PlexNotConfigured as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
try:
|
||
with plex:
|
||
data, ct = plex.image_bytes(key, w, h)
|
||
except PlexError as e:
|
||
raise HTTPException(status_code=502, detail=f"Plex image fetch failed: {e}")
|
||
_img_cache_write(cache_key, data, ct)
|
||
return _img_response(data, ct)
|
||
|
||
|
||
@router.get("/subtitle/{rating_key}/{sub_ord}")
|
||
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)
|
||
AND embedded text subs (extracted from the local file). Image subs (PGS/VobSub) → 415. Disk-cached."""
|
||
_require_session(request)
|
||
# Cache the ABSOLUTE-time VTT once (per rk+ord); the per-session cue-shift is applied on the way
|
||
# out, so a resume/seek to any offset reuses the same cached track (no cache-per-offset explosion).
|
||
cache_key = f"sub_{rating_key}_{sub_ord}"
|
||
hit = _sub_cache_read(cache_key)
|
||
if hit is not None:
|
||
return Response(_shift_vtt(hit, offset), media_type="text/vtt")
|
||
try:
|
||
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]
|
||
if sub_ord < 0 or sub_ord >= len(subs):
|
||
raise HTTPException(status_code=404, detail="No such subtitle")
|
||
s = subs[sub_ord]
|
||
codec = (s.get("codec") or s.get("format") or "").lower()
|
||
if codec in _BITMAP_SUBS:
|
||
raise HTTPException(status_code=415, detail="Image-based subtitle can't be shown as text")
|
||
if s.get("key"): # external sidecar → fetch from Plex, convert to VTT
|
||
raw = plex.raw_get(s["key"])
|
||
if codec in ("srt", "subrip", ""):
|
||
vtt = _srt_to_vtt(raw.decode("utf-8", "replace"))
|
||
else:
|
||
fd, tmp = tempfile.mkstemp(suffix="." + (codec or "sub"))
|
||
try:
|
||
os.write(fd, raw)
|
||
os.close(fd)
|
||
vtt = _ffmpeg_to_vtt(tmp, None)
|
||
finally:
|
||
os.unlink(tmp)
|
||
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)
|
||
vtt = _ffmpeg_to_vtt(str(src), emb_ord)
|
||
else:
|
||
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:
|
||
raise HTTPException(status_code=502, detail=f"Subtitle fetch failed: {e}")
|
||
_sub_cache_write(cache_key, vtt)
|
||
return Response(_shift_vtt(vtt, offset), media_type="text/vtt")
|
||
|
||
|
||
# --- Playback (local file → direct 206 or on-the-fly HLS remux; P2) ----------------------------
|
||
|
||
|
||
def _item_or_404(db: Session, rating_key: str) -> PlexItem:
|
||
it = db.query(PlexItem).filter_by(rating_key=str(rating_key)).first()
|
||
if it is None:
|
||
raise HTTPException(status_code=404, detail="Unknown Plex item")
|
||
return it
|
||
|
||
|
||
# Progress thresholds (mirror the YouTube player): ignore the first few seconds, and treat the
|
||
# last stretch as "finished" (mark watched, clear the resume point).
|
||
_PROGRESS_MIN_S = 5
|
||
_FINISH_MARGIN_S = 30
|
||
|
||
|
||
# Cast/crew photos come from Plex's PUBLIC metadata CDN (no token). We proxy them (host-whitelisted)
|
||
# so the user's browser makes no third-party request (privacy + self-host CSP friendliness).
|
||
_PERSON_IMG_HOST = "https://metadata-static.plex.tv/"
|
||
|
||
|
||
def _rich_meta(meta: dict) -> dict:
|
||
"""Pull the "info page" extras out of a full Plex metadata dict: an IMDb score + link, content
|
||
rating, genres, director(s), studio, tagline, and cast (name/role/photo). Best-effort — any
|
||
missing field is just omitted."""
|
||
# Rating: prefer the explicit IMDb entry in the Rating array, else the generic audienceRating.
|
||
imdb_rating = None
|
||
for r in meta.get("Rating") or []:
|
||
if str(r.get("image") or "").startswith("imdb://"):
|
||
try:
|
||
imdb_rating = round(float(r.get("value")), 1)
|
||
except (TypeError, ValueError):
|
||
pass
|
||
break
|
||
if imdb_rating is None:
|
||
try:
|
||
imdb_rating = round(float(meta.get("audienceRating") or meta.get("rating")), 1)
|
||
except (TypeError, ValueError):
|
||
imdb_rating = None
|
||
# IMDb id (tt…) from the Guid list → a clickable link.
|
||
imdb_id = None
|
||
for g in meta.get("Guid") or []:
|
||
gid = str(g.get("id") or "")
|
||
if gid.startswith("imdb://"):
|
||
imdb_id = gid.split("imdb://", 1)[1]
|
||
break
|
||
cast = []
|
||
for role in (meta.get("Role") or [])[:24]:
|
||
name = role.get("tag")
|
||
if not name:
|
||
continue
|
||
thumb = str(role.get("thumb") or "")
|
||
cast.append(
|
||
{
|
||
"name": name,
|
||
"role": role.get("role"),
|
||
"thumb": f"/api/plex/person-image?u={quote(thumb, safe='')}"
|
||
if thumb.startswith(_PERSON_IMG_HOST)
|
||
else None,
|
||
}
|
||
)
|
||
return {
|
||
"imdb_rating": imdb_rating,
|
||
"imdb_id": imdb_id,
|
||
"imdb_url": f"https://www.imdb.com/title/{imdb_id}/" if imdb_id else None,
|
||
"content_rating": meta.get("contentRating"),
|
||
"genres": [g.get("tag") for g in (meta.get("Genre") or []) if g.get("tag")][:8],
|
||
"directors": [d.get("tag") for d in (meta.get("Director") or []) if d.get("tag")][:4],
|
||
"studio": meta.get("studio"),
|
||
"tagline": meta.get("tagline"),
|
||
"cast": cast,
|
||
}
|
||
|
||
|
||
@router.get("/person-image")
|
||
def person_image(u: str, request: Request) -> Response:
|
||
"""Proxy a cast/crew photo from Plex's public metadata CDN (host-whitelisted; no token needed).
|
||
Signed-session auth (no DB) so it, like /image, never holds a pool connection during the fetch."""
|
||
_require_session(request)
|
||
if not u.startswith(_PERSON_IMG_HOST):
|
||
raise HTTPException(status_code=400, detail="Unsupported image host")
|
||
cache_key = "person_" + hashlib.sha1(u.encode()).hexdigest()
|
||
hit = _img_cache_read(cache_key)
|
||
if hit:
|
||
return _img_response(*hit)
|
||
try:
|
||
with httpx.Client(timeout=10.0, follow_redirects=True) as c:
|
||
r = c.get(u)
|
||
r.raise_for_status()
|
||
except httpx.HTTPError:
|
||
raise HTTPException(status_code=502, detail="Image fetch failed")
|
||
ct = r.headers.get("content-type", "image/jpeg")
|
||
_img_cache_write(cache_key, r.content, ct)
|
||
return _img_response(r.content, ct)
|
||
|
||
|
||
# Known external list providers that seed Plex collections (via plextraktsync et al). A collection's
|
||
# "source" buckets the info-page strips so the user can show/hide each type independently (e.g. hide
|
||
# the noisy 'IMDb Popular'/'TMDb Trending' auto-lists but keep genuine franchise collections). Derived
|
||
# from the already-synced title/smart — no schema change, no re-sync. Unknown providers stay "collection".
|
||
_STRIP_PROVIDERS = ("imdb", "tmdb", "tvdb", "trakt")
|
||
|
||
|
||
def _collection_source(col: PlexCollection) -> str:
|
||
first = (col.title or "").strip().split(" ", 1)[0].lower()
|
||
if first in _STRIP_PROVIDERS:
|
||
return first
|
||
if col.smart:
|
||
return "smart"
|
||
return "collection"
|
||
|
||
|
||
def _collection_strips(db: Session, it: PlexItem, user_id: int) -> list[dict]:
|
||
"""The collections this movie belongs to, each with its member titles (playable cards) — the
|
||
'Avatar Collection' strip on the info page. Pure local lookup (no Plex call)."""
|
||
keys = it.collection_keys or []
|
||
if not keys or it.kind != "movie":
|
||
return []
|
||
cols = {c.rating_key: c for c in db.query(PlexCollection).filter(PlexCollection.rating_key.in_(keys))}
|
||
# 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))
|
||
out = []
|
||
for col in ordered:
|
||
rk = col.rating_key
|
||
members = (
|
||
db.query(PlexItem)
|
||
.filter(
|
||
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)
|
||
.all()
|
||
)
|
||
ids = [m.id for m in members]
|
||
states = {
|
||
s.item_id: s
|
||
for s in db.query(PlexState).filter(
|
||
PlexState.user_id == user_id, PlexState.item_id.in_(ids or [0])
|
||
)
|
||
}
|
||
out.append(
|
||
{
|
||
"id": rk,
|
||
"title": col.title,
|
||
"source": _collection_source(col),
|
||
"items": [_movie_card(m, states.get(m.id)) for m in members],
|
||
}
|
||
)
|
||
return out
|
||
|
||
|
||
def _episode_nav(db: Session, it: PlexItem) -> tuple[str | None, str | None]:
|
||
if it.kind != "episode" or it.show_id is None:
|
||
return None, None
|
||
keys = [
|
||
r[0]
|
||
for r in db.query(PlexItem.rating_key)
|
||
.filter_by(show_id=it.show_id, kind="episode")
|
||
.order_by(PlexItem.season_number.asc().nullsfirst(), PlexItem.episode_number.asc().nullsfirst())
|
||
.all()
|
||
]
|
||
try:
|
||
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)
|
||
|
||
|
||
@router.get("/item/{rating_key}")
|
||
def item_detail(
|
||
rating_key: str,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Everything the player needs: metadata, cast, intro/credit markers (from Plex), episode
|
||
prev/next, and the per-user resume position + watch status."""
|
||
it = _item_or_404(db, rating_key)
|
||
st = db.query(PlexState).filter_by(user_id=user.id, item_id=it.id).first()
|
||
|
||
rich: dict = {}
|
||
markers: list[dict] = []
|
||
audio_streams: list[dict] = []
|
||
subtitle_streams: list[dict] = []
|
||
try:
|
||
with PlexClient(db) as plex:
|
||
meta = plex.metadata(it.rating_key, markers=True) or {}
|
||
rich = _rich_meta(meta)
|
||
for m in meta.get("Marker") or []:
|
||
if m.get("type") in ("intro", "credits"):
|
||
markers.append(
|
||
{
|
||
"type": m.get("type"),
|
||
"start_s": round((m.get("startTimeOffset") or 0) / 1000, 1),
|
||
"end_s": round((m.get("endTimeOffset") or 0) / 1000, 1),
|
||
}
|
||
)
|
||
# Audio + subtitle tracks (ordinals among their stream type — used to -map the selection).
|
||
part = ((meta.get("Media") or [{}])[0].get("Part") or [{}])[0]
|
||
for s in part.get("Stream") or []:
|
||
if s.get("streamType") == 2:
|
||
audio_streams.append(
|
||
{
|
||
"ord": len(audio_streams),
|
||
"label": s.get("displayTitle") or s.get("language") or f"Audio {len(audio_streams) + 1}",
|
||
"language": s.get("languageTag") or s.get("language"),
|
||
"default": bool(s.get("selected") or s.get("default")),
|
||
}
|
||
)
|
||
elif s.get("streamType") == 3:
|
||
codec = (s.get("codec") or s.get("format") or "").lower()
|
||
subtitle_streams.append(
|
||
{
|
||
"ord": len(subtitle_streams),
|
||
"label": s.get("displayTitle") or s.get("language") or f"Subtitle {len(subtitle_streams) + 1}",
|
||
"language": s.get("languageTag") or s.get("language"),
|
||
"codec": codec,
|
||
# Text subs (srt/ass/…) can be served as WebVTT tracks; image subs (PGS/VobSub)
|
||
# can't be turned into text, so the player hides them (burn-in is a later phase).
|
||
"text": codec not in _BITMAP_SUBS,
|
||
}
|
||
)
|
||
except Exception:
|
||
pass # metadata extras are best-effort; any live-Plex failure must degrade, not 500 — playback works without them
|
||
|
||
prev_id, next_id = _episode_nav(db, it)
|
||
show = db.get(PlexShow, it.show_id) if it.kind == "episode" and it.show_id else None
|
||
return {
|
||
"id": it.rating_key,
|
||
"kind": it.kind,
|
||
"title": it.title,
|
||
"summary": it.summary,
|
||
"year": it.year,
|
||
"duration_seconds": it.duration_s,
|
||
"playable": it.playable,
|
||
"thumb": f"/api/plex/image/{it.rating_key}",
|
||
"art": f"/api/plex/image/{it.rating_key}?variant=art",
|
||
"library": _lib_key(db, it.library_id),
|
||
"cast": rich.get("cast", []),
|
||
"imdb_rating": rich.get("imdb_rating"),
|
||
"imdb_id": rich.get("imdb_id"),
|
||
"imdb_url": rich.get("imdb_url"),
|
||
"content_rating": rich.get("content_rating"),
|
||
"genres": rich.get("genres", []),
|
||
"directors": rich.get("directors", []),
|
||
"studio": rich.get("studio"),
|
||
"tagline": rich.get("tagline"),
|
||
"markers": markers,
|
||
"audio_streams": audio_streams,
|
||
"subtitle_streams": subtitle_streams,
|
||
"status": st.status if st else "new",
|
||
"position_seconds": st.position_seconds if st else 0,
|
||
"show_title": show.title if show else None,
|
||
"season_number": it.season_number,
|
||
"episode_number": it.episode_number,
|
||
"prev_id": prev_id,
|
||
"next_id": next_id,
|
||
"collections": _collection_strips(db, it, user.id),
|
||
}
|
||
|
||
|
||
def _push_watch(
|
||
background: BackgroundTasks,
|
||
db: Session,
|
||
user_id: int,
|
||
item_id: int,
|
||
rating_key: str,
|
||
action: str,
|
||
time_ms: int = 0,
|
||
duration_ms: int = 0,
|
||
) -> None:
|
||
"""Schedule a best-effort Siftlode→Plex watch push, but only for a user whose owner link has
|
||
push enabled — non-owner users never touch Plex. Guarding here (with the request session) avoids
|
||
spinning up a throwaway background session on every state change for the common no-link case."""
|
||
if plex_watch.link_for_push(db, user_id) is None:
|
||
return
|
||
background.add_task(
|
||
plex_watch.push_state_to_plex, user_id, item_id, rating_key, action, time_ms, duration_ms
|
||
)
|
||
|
||
|
||
@router.post("/item/{rating_key}/progress")
|
||
def item_progress(
|
||
rating_key: str,
|
||
payload: dict,
|
||
background: BackgroundTasks,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Checkpoint the resume position while playing (near the end → mark watched + clear it).
|
||
|
||
`final` (sent on the pause/pagehide/unmount flush, not the periodic 10s checkpoint) is what
|
||
debounces the Plex resume push: we mirror the settled position to Plex only on a final flush, so
|
||
a single watch doesn't spray `/:/timeline` calls at the server every 10 seconds."""
|
||
it = _item_or_404(db, rating_key)
|
||
try:
|
||
position = max(0, int(payload.get("position_seconds") or 0))
|
||
duration = int(payload.get("duration_seconds") or 0)
|
||
except (TypeError, ValueError):
|
||
raise HTTPException(status_code=400, detail="position_seconds must be an integer")
|
||
final = bool(payload.get("final"))
|
||
now = datetime.now(timezone.utc)
|
||
st = db.query(PlexState).filter_by(user_id=user.id, item_id=it.id).first()
|
||
was_watched = st is not None and st.status == "watched"
|
||
|
||
near_end = duration > 0 and position > duration - _FINISH_MARGIN_S
|
||
if near_end:
|
||
if st is None:
|
||
st = PlexState(user_id=user.id, item_id=it.id)
|
||
db.add(st)
|
||
st.status = "watched"
|
||
st.watched_at = now
|
||
st.position_seconds = 0
|
||
st.progress_updated_at = now
|
||
st.synced_to_plex = False
|
||
db.commit()
|
||
# Immediate on the watched transition; skip a repeat scrobble if it was already watched
|
||
# (a later checkpoint of the same finished item would otherwise bump Plex's viewCount again).
|
||
if not was_watched:
|
||
_push_watch(background, db, user.id, it.id, rating_key, "watched")
|
||
return {"status": "watched", "position_seconds": 0}
|
||
|
||
if position < _PROGRESS_MIN_S:
|
||
if st is not None and st.status == "new":
|
||
db.delete(st)
|
||
elif st is not None:
|
||
st.position_seconds = 0
|
||
st.progress_updated_at = now
|
||
db.commit()
|
||
return {"position_seconds": 0}
|
||
|
||
if st is None:
|
||
st = PlexState(user_id=user.id, item_id=it.id)
|
||
db.add(st)
|
||
st.position_seconds = position
|
||
st.progress_updated_at = now
|
||
if final:
|
||
st.synced_to_plex = False
|
||
db.commit()
|
||
if final:
|
||
_push_watch(
|
||
background, db, user.id, it.id, rating_key, "resume", position * 1000, duration * 1000
|
||
)
|
||
return {"position_seconds": position}
|
||
|
||
|
||
@router.post("/item/{rating_key}/state")
|
||
def item_state(
|
||
rating_key: str,
|
||
payload: dict,
|
||
background: BackgroundTasks,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Set the per-user watch status (new|watched|hidden). watched→scrobble / →new→unscrobble push
|
||
to a linked Plex account immediately; `hidden` is a Siftlode-only concept with no Plex analogue,
|
||
so it never touches Plex."""
|
||
it = _item_or_404(db, rating_key)
|
||
status = payload.get("status")
|
||
if status not in ("new", "watched", "hidden"):
|
||
raise HTTPException(status_code=400, detail="Invalid status")
|
||
st = db.query(PlexState).filter_by(user_id=user.id, item_id=it.id).first()
|
||
prev_status = st.status if st is not None else "new"
|
||
if status == "new":
|
||
if st is not None:
|
||
db.delete(st)
|
||
db.commit()
|
||
if prev_status != "new": # something → unwatched: mirror the un-mark to Plex
|
||
_push_watch(background, db, user.id, it.id, rating_key, "unwatched")
|
||
return {"status": "new"}
|
||
if st is None:
|
||
st = PlexState(user_id=user.id, item_id=it.id)
|
||
db.add(st)
|
||
st.status = status
|
||
if status == "watched":
|
||
st.watched_at = datetime.now(timezone.utc)
|
||
st.position_seconds = 0
|
||
st.synced_to_plex = False
|
||
db.commit()
|
||
if status == "watched" and prev_status != "watched":
|
||
_push_watch(background, db, user.id, it.id, rating_key, "watched")
|
||
return {"status": status}
|
||
|
||
|
||
def _bulk_state(
|
||
background: BackgroundTasks, db: Session, user_id: int, eps: list[PlexItem], watched: bool
|
||
) -> int:
|
||
"""Mark every episode in `eps` watched (or unwatched) for a user, mirroring each change to a
|
||
linked Plex account in the background (best-effort). Returns how many rows actually changed."""
|
||
now = datetime.now(timezone.utc)
|
||
existing = {
|
||
s.item_id: s
|
||
for s in db.query(PlexState).filter(
|
||
PlexState.user_id == user_id, PlexState.item_id.in_([e.id for e in eps] or [0])
|
||
)
|
||
}
|
||
pushable = plex_watch.link_for_push(db, user_id) is not None
|
||
to_push: list[tuple[int, str, str]] = []
|
||
for e in eps:
|
||
st = existing.get(e.id)
|
||
prev = st.status if st is not None else "new"
|
||
if watched:
|
||
if st is None:
|
||
st = PlexState(user_id=user_id, item_id=e.id)
|
||
db.add(st)
|
||
st.status = "watched"
|
||
st.watched_at = now
|
||
st.position_seconds = 0
|
||
st.synced_to_plex = False
|
||
if prev != "watched":
|
||
to_push.append((e.id, e.rating_key, "watched"))
|
||
else: # → new: drop any state (but keep the user's private "hidden" marks)
|
||
if st is not None and prev != "hidden":
|
||
db.delete(st)
|
||
if prev != "new":
|
||
to_push.append((e.id, e.rating_key, "unwatched"))
|
||
db.commit()
|
||
if pushable and to_push:
|
||
# One coalesced background task for the whole batch (reuses a single session + Plex client),
|
||
# not one task per episode — a 200-ep show mark is 1 task, not 200.
|
||
background.add_task(plex_watch.push_bulk_state_to_plex, user_id, to_push)
|
||
return len(to_push)
|
||
|
||
|
||
@router.post("/show/{rating_key}/state")
|
||
def show_state(
|
||
rating_key: str,
|
||
payload: dict,
|
||
background: BackgroundTasks,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Mark a whole show watched/unwatched (all its episodes) for the current user + push to Plex."""
|
||
sh = db.query(PlexShow).filter_by(rating_key=str(rating_key)).first()
|
||
if sh is None:
|
||
raise HTTPException(status_code=404, detail="Unknown Plex show")
|
||
watched = bool(payload.get("watched"))
|
||
eps = db.query(PlexItem).filter_by(show_id=sh.id, kind="episode").all()
|
||
changed = _bulk_state(background, db, user.id, eps, watched)
|
||
return {"changed": changed, "watched": watched}
|
||
|
||
|
||
@router.post("/season/{rating_key}/state")
|
||
def season_state(
|
||
rating_key: str,
|
||
payload: dict,
|
||
background: BackgroundTasks,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Mark a whole season watched/unwatched (all its episodes) for the current user + push to Plex."""
|
||
se = db.query(PlexSeason).filter_by(rating_key=str(rating_key)).first()
|
||
if se is None:
|
||
raise HTTPException(status_code=404, detail="Unknown Plex season")
|
||
watched = bool(payload.get("watched"))
|
||
eps = db.query(PlexItem).filter_by(season_id=se.id, kind="episode").all()
|
||
changed = _bulk_state(background, db, user.id, eps, watched)
|
||
return {"changed": changed, "watched": watched}
|
||
|
||
|
||
@router.post("/stream/{rating_key}/session")
|
||
def stream_session(
|
||
rating_key: str,
|
||
start: float = 0.0,
|
||
audio: int | None = None,
|
||
aoff: float = 0.0,
|
||
multi: bool = False,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> dict:
|
||
"""Prepare playback from `start` seconds. Direct-playable files are served raw; remux files
|
||
(re)start an HLS session at the offset (seek-restart); transcode (HEVC/VP9) is P3. Selecting a
|
||
non-default audio track (`audio` = stream ordinal) forces the HLS path so the chosen audio can be
|
||
muxed in. Subtitles are independent WebVTT tracks (GET /subtitle) — no session restart."""
|
||
plex_stream.reap_idle() # opportunistic cleanup of idle sessions on each new playback
|
||
it = _item_or_404(db, rating_key)
|
||
if it.playable == "transcode":
|
||
raise HTTPException(status_code=501, detail="This format needs transcoding (a later phase).")
|
||
# `multi` (item has ≥2 audio tracks) forces the HLS path so ALL audio tracks ship as renditions and
|
||
# the client can switch audio without a restart — even for otherwise direct-playable files.
|
||
if it.playable == "direct" and audio is None and not aoff and not multi:
|
||
return {"mode": "direct", "url": f"/api/plex/stream/{it.rating_key}/file", "start_s": 0.0}
|
||
if plex_paths.local_media_path(db, it.file_path) is None:
|
||
raise HTTPException(status_code=404, detail="Media file not found on disk")
|
||
s = plex_stream.start_session(db, it, start, audio, aoff, multi)
|
||
if s is None:
|
||
raise HTTPException(status_code=404, detail="Media file not found on disk")
|
||
# Report the REAL media start (the keyframe ffmpeg landed on, which hls.js zero-bases to), not the
|
||
# requested offset — the client's absolute clock and the subtitle cue-shift both key off this.
|
||
return {"mode": "hls", "start_s": s.media_start_s, "url": f"/api/plex/stream/{it.rating_key}/hls/{s.entry}"}
|
||
|
||
|
||
@router.get("/stream/{rating_key}/file")
|
||
def stream_file(
|
||
rating_key: str,
|
||
download: bool = False,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> FileResponse:
|
||
"""Serve the raw local media file with HTTP range support. Used both for direct-play (inline)
|
||
and for the player's "download original" button (`?download=1` → attachment). The download is
|
||
the untouched physical file — no re-encode/repackage."""
|
||
it = _item_or_404(db, rating_key)
|
||
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")
|
||
if download:
|
||
# 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() or "video"
|
||
return FileResponse(str(src), filename=f"{base}{ext}")
|
||
return FileResponse(str(src)) # Starlette honours the Range header (206)
|
||
|
||
|
||
_HLS_CT = {".m3u8": "application/vnd.apple.mpegurl", ".ts": "video/mp2t", ".vtt": "text/vtt"}
|
||
|
||
|
||
@router.get("/stream/{rating_key}/hls/{filename}")
|
||
def stream_hls_file(
|
||
rating_key: str,
|
||
filename: str,
|
||
user: User = Depends(current_user),
|
||
db: Session = Depends(get_db),
|
||
) -> Response:
|
||
"""Serve a file (playlist / segment / subtitle) from the current HLS session directory. The
|
||
playlist references its segments/subtitles by relative name, all resolving back here."""
|
||
# Filename must be a plain hls artifact — no path separators, only the expected extensions.
|
||
ext = "." + filename.rsplit(".", 1)[-1] if "." in filename else ""
|
||
if ext not in _HLS_CT or "/" in filename or "\\" in filename or ".." in filename:
|
||
raise HTTPException(status_code=404, detail="Not found")
|
||
s = plex_stream.current_session(str(rating_key))
|
||
if s is None:
|
||
# No session yet (e.g. reaped): the ENTRY playlist may auto-start one at 0 — master.m3u8 for a
|
||
# multi-audio item, index.m3u8 for a single-audio remux item.
|
||
it = _item_or_404(db, rating_key)
|
||
if filename == "master.m3u8":
|
||
s = plex_stream.start_session(db, it, 0.0, multi=True)
|
||
elif filename == "index.m3u8" and it.playable == "remux":
|
||
s = plex_stream.start_session(db, it, 0.0)
|
||
else:
|
||
raise HTTPException(status_code=404, detail="No active playback session")
|
||
if s is None:
|
||
raise HTTPException(status_code=404, detail="Media file not found on disk")
|
||
path = s.dir / filename
|
||
timeout = 30 if ext == ".m3u8" else 20
|
||
if not plex_stream.wait_for(path, timeout):
|
||
raise HTTPException(status_code=404, detail="Not available yet")
|
||
return Response(
|
||
content=path.read_bytes(), media_type=_HLS_CT[ext], headers={"Cache-Control": "no-store"}
|
||
)
|