peter
533571f572
PlexLibrary, PlexShow, PlexSeason, PlexItem, PlexPerson, PlexCollection, PlexState, PlexLink, PlexPlaylist and PlexPlaylistItem leave app/models.py for app/plex/models.py; app.tables registers them. Every import is re-pointed; no schema change.
266 lines
11 KiB
Python
266 lines
11 KiB
Python
"""Plex people: cast/crew filter-chip cards + a single person's filmography page."""
|
|
|
|
import threading
|
|
import time
|
|
|
|
from fastapi import APIRouter, BackgroundTasks, Depends
|
|
from sqlalchemy import func, or_, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.collation import collated
|
|
from app import logs, sysconfig
|
|
from app.auth import current_user
|
|
from app.db import SessionLocal, get_db
|
|
from app.models import User
|
|
from app.plex.models import PlexItem, PlexPerson, PlexShow
|
|
from app.plex import rollup
|
|
from app.plex import tmdb as plex_tmdb
|
|
from app.plex.cards import SHOW_NEW, movie_card, norm_lang, show_card
|
|
from app.plex.query import content_libs, split_csv, title_col
|
|
|
|
router = APIRouter(prefix="/api/plex", tags=["plex"])
|
|
log = logs.get_logger(__name__)
|
|
|
|
|
|
# How many "Known for" titles the person page shows (the stored pool is deeper; see plex.tmdb).
|
|
_KNOWN_FOR_SHOWN = 15
|
|
|
|
|
|
def _resolve_known_for(
|
|
db: Session,
|
|
known_for: list | None,
|
|
uid: int,
|
|
movie_lib_ids: list[int],
|
|
show_lib_ids: list[int],
|
|
lang: str,
|
|
) -> list[dict]:
|
|
"""The person's TMDB "Known for" credits (most-voted first) that are IN our library, as cards, in
|
|
that order, at most _KNOWN_FOR_SHOWN. Matched by the canonical guid `tmdb:<id>`; out-of-library
|
|
credits are dropped."""
|
|
if not known_for:
|
|
return []
|
|
# Match each credit to a library row by guid, bucketed by media_type (movie ids and tv ids collide
|
|
# numerically) and scoped to the enabled libraries — the shared helper owns that collision-safe
|
|
# logic (the detail-page recs use the same one).
|
|
movies, shows = plex_tmdb.resolve_library_guids(
|
|
db, known_for, movie_lib_ids=movie_lib_ids, show_lib_ids=show_lib_ids
|
|
)
|
|
m_states = rollup.item_state_map(db, uid, [m.id for m in movies.values()])
|
|
show_statuses = rollup.state_map(db, uid, [s.id for s in shows.values()])
|
|
out: list[dict] = []
|
|
for k in known_for:
|
|
g = f"tmdb:{k.get('tmdb_id')}"
|
|
# A credit resolves against its OWN media_type's bucket only.
|
|
if k.get("media_type") == "tv":
|
|
if g in shows:
|
|
out.append(show_card(shows[g], show_statuses.get(shows[g].id, SHOW_NEW), lang=lang))
|
|
elif g in movies:
|
|
out.append(movie_card(movies[g], m_states.get(movies[g].id), lang=lang))
|
|
return out[:_KNOWN_FOR_SHOWN]
|
|
|
|
|
|
@router.get("/people/cards")
|
|
def people_cards(
|
|
names: str,
|
|
scope: str = "both",
|
|
user: User = Depends(current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> dict:
|
|
"""Cards for the actor filter-chips currently applied: each name + its cached headshot + how many
|
|
movies/shows (in the given scope) feature them. Photos come from the plex_people cache (populated
|
|
as items are rich-fetched — info-page view + the rich re-sync); counts are live against cast_names.
|
|
A name with no cached photo yet still returns a card (the UI shows a placeholder)."""
|
|
wanted = split_csv(names)[:16]
|
|
if not wanted:
|
|
return {"people": []}
|
|
movie_lib_ids, show_lib_ids = content_libs(db)
|
|
want_movies = scope in ("movie", "both") and bool(movie_lib_ids)
|
|
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()
|
|
}
|
|
out = []
|
|
for nm in wanted:
|
|
count = 0
|
|
if want_movies:
|
|
count += (
|
|
db.scalar(
|
|
select(func.count(PlexItem.id)).where(
|
|
PlexItem.kind == "movie",
|
|
PlexItem.library_id.in_(movie_lib_ids),
|
|
PlexItem.cast_names.contains([nm]),
|
|
)
|
|
)
|
|
or 0
|
|
)
|
|
if want_shows:
|
|
count += (
|
|
db.scalar(
|
|
select(func.count(PlexShow.id)).where(
|
|
PlexShow.library_id.in_(show_lib_ids),
|
|
PlexShow.cast_names.contains([nm]),
|
|
)
|
|
)
|
|
or 0
|
|
)
|
|
out.append({"name": nm, "photo": photos.get(nm), "count": count})
|
|
return {"people": out}
|
|
|
|
|
|
# Cap each filmography section — a prolific person shouldn't return an unbounded list the client then
|
|
# mounts a card per row for (the grid paginates at PAGE; this page renders all at once). Ample for a
|
|
# personal library; the most-recent titles win via the year-desc order.
|
|
_PERSON_SECTION_MAX = 200
|
|
|
|
|
|
# A person's bio is enriched at most once per this window: it dedups concurrent opens of the same person
|
|
# (each would otherwise schedule its own 8s TMDB task) AND rate-limits re-triggering when TMDB is
|
|
# down/slow (a transient failure leaves tmdb_enriched_at NULL, so without this every reload would spawn a
|
|
# fresh task and pile up on the shared threadpool). In-process + best-effort: a restart just clears it, at
|
|
# worst costing a few extra fetches. A successful enrich stamps the watermark, so the reservation only
|
|
# ever expires harmlessly.
|
|
_ENRICH_COOLDOWN_S = 60.0
|
|
_enrich_inflight: dict[int, float] = {}
|
|
_enrich_lock = threading.Lock()
|
|
|
|
|
|
def _should_schedule_enrich(person_id: int) -> bool:
|
|
"""True (and reserves a cooldown) if this person isn't already being enriched / recently attempted."""
|
|
now = time.monotonic()
|
|
with _enrich_lock:
|
|
deadline = _enrich_inflight.get(person_id)
|
|
if deadline is not None and now < deadline:
|
|
return False
|
|
_enrich_inflight[person_id] = now + _ENRICH_COOLDOWN_S
|
|
# Bound the map: drop expired reservations once it grows (a large library has many people).
|
|
if len(_enrich_inflight) > 1024:
|
|
for pid in [p for p, d in _enrich_inflight.items() if d <= now]:
|
|
del _enrich_inflight[pid]
|
|
return True
|
|
|
|
|
|
def _enrich_person_bg(person_id: int) -> None:
|
|
"""Fetch + persist one person's TMDB bio OFF the request path — a FastAPI background task that runs
|
|
AFTER the response is sent, so the outbound TMDB call never sits on the serve latency (the module's
|
|
"no live TMDB call at serve time" invariant). The request's session is already closed by then, so
|
|
open a fresh one. Best-effort: a TMDB failure just leaves `tmdb_enriched_at` NULL to retry on the
|
|
next open, and the bio lands from the row by then."""
|
|
db = SessionLocal()
|
|
try:
|
|
person = db.get(PlexPerson, person_id)
|
|
if person is not None:
|
|
plex_tmdb.enrich_person(db, person)
|
|
except Exception: # noqa: BLE001 — background best-effort; never surfaces to a user
|
|
db.rollback()
|
|
log.warning("background person bio enrich failed for id=%s", person_id, exc_info=True)
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.get("/person/{name}")
|
|
def person_detail(
|
|
name: str,
|
|
background_tasks: BackgroundTasks,
|
|
lang: str = "en",
|
|
user: User = Depends(current_user),
|
|
db: Session = Depends(get_db),
|
|
) -> dict:
|
|
"""One cast/crew member's filmography: their cached headshot + the movies and shows (in the enabled
|
|
libraries) whose cast OR directors include this name — the inverse of the cast-name → library-filter
|
|
link. The name string is the identity key (Plex cast carries no stable per-person id), so distinct
|
|
people who share a name share a page. Each section is capped at _PERSON_SECTION_MAX. An unknown name
|
|
simply returns empty sections.
|
|
|
|
The first time a page is opened, the person's TMDB bio + "Known for" credits are lazily
|
|
fetched (from the linked `tmdb_person_id`) and persisted, then served from the row on every open.
|
|
The fetch runs OFF the request path (a background task); the first open serves whatever's in the row
|
|
with `enriching` set, and the page asks again until the bio lands. The people_enrich job
|
|
fetches everyone ahead of time, so this lazy path is only for a person the job hasn't reached yet.
|
|
"""
|
|
lang = norm_lang(lang)
|
|
person = db.execute(select(PlexPerson).where(PlexPerson.name == name)).scalars().first()
|
|
# Lazy one-time bio enrich, scheduled AFTER the response so the TMDB call is never on the serve path.
|
|
# Gated by a per-person cooldown so concurrent/rapid opens (or repeated opens while TMDB is degraded)
|
|
# can't pile background tasks onto the shared threadpool.
|
|
# `enriching` tells the page the bio is on its way: it asks again shortly instead of showing
|
|
# an empty page until the next open. True while a fetch is pending, including one an earlier open
|
|
# already reserved.
|
|
enriching = (
|
|
person is not None
|
|
and bool(person.tmdb_person_id)
|
|
and person.tmdb_enriched_at is None
|
|
and bool(sysconfig.get_str(db, "tmdb_api_key"))
|
|
)
|
|
if enriching and person is not None and _should_schedule_enrich(person.id):
|
|
background_tasks.add_task(_enrich_person_bg, person.id)
|
|
movie_lib_ids, show_lib_ids = content_libs(db)
|
|
|
|
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]),
|
|
),
|
|
)
|
|
.order_by(
|
|
PlexItem.year.desc().nullslast(), collated(title_col(PlexItem, lang), lang)
|
|
)
|
|
.limit(_PERSON_SECTION_MAX)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
states = rollup.item_state_map(db, user.id, [it.id for it in items])
|
|
movies = [movie_card(it, states.get(it.id), lang=lang) 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]),
|
|
),
|
|
)
|
|
.order_by(
|
|
PlexShow.year.desc().nullslast(), collated(title_col(PlexShow, lang), lang)
|
|
)
|
|
.limit(_PERSON_SECTION_MAX)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
statuses = rollup.state_map(db, user.id, [s.id for s in show_rows])
|
|
shows = [show_card(sh, statuses.get(sh.id, SHOW_NEW), lang=lang) for sh in show_rows]
|
|
|
|
known_for = _resolve_known_for(
|
|
db, person.known_for if person else None, user.id, movie_lib_ids, show_lib_ids, lang
|
|
)
|
|
return {
|
|
"name": name,
|
|
"photo": person.photo_thumb if person else None,
|
|
# The Hungarian biography for a Hungarian reader, the instance-language one when TMDB has none.
|
|
"biography": ((person.biography_hu if lang == "hu" else None) or person.biography)
|
|
if person
|
|
else None,
|
|
"birthday": person.birthday if person else None,
|
|
"deathday": person.deathday if person else None,
|
|
"place_of_birth": person.place_of_birth if person else None,
|
|
"known_for_department": person.known_for_department if person else None,
|
|
"also_known_as": (person.also_known_as if person else None) or [],
|
|
"known_for": known_for,
|
|
"enriching": enriching,
|
|
"movies": movies,
|
|
"shows": shows,
|
|
}
|