peter
ab963c81d2
- people_enrich: a failed TMDB lookup or a dead headshot is skipped, not the end of the run (a dead file is marked and left for a week; three failures in a row end it); portraits wait for the Plex module switch; a no-Plex original keeps its own cache key, so the resize still replaces it; the job entry lives in the plex domain (run_people_enrich) - person-image takes only a headshot-shaped CDN url (no query variants of one file) - every synced row gets Hungarian genres, and a HU genre filter matches the word as picked too; migration 0094 fills the rows no overlay reached - a job run's audit row carries its result as data; audit_clear / demo_reset store their counts - one credit-column list for the prune and the enrichment order; _overlay_pass typed - tests: batch skip + stop, HU bio stored, dead headshots, module switch, the person-image route, the job body, genre filter + facet write + twin fallback, tagline/summary fallbacks, audit data, the reader's alphabet at every remaining collated() call site
124 lines
4.7 KiB
Python
124 lines
4.7 KiB
Python
"""Thin on-disk cache + proxy helpers for Plex poster/art images.
|
||
|
||
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).
|
||
|
||
The cache directory (``cache.CACHE_DIR``) is shared with the subtitle cache (see ``subtitles.py``).
|
||
"""
|
||
|
||
import time
|
||
from datetime import timedelta
|
||
|
||
from fastapi import Response
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app import logs
|
||
from app.models import PlexCollection, PlexItem, PlexSeason, PlexShow
|
||
from app.plex.cache import CACHE_DIR
|
||
from app.plex.lookups import by_rating_key
|
||
|
||
log = logs.get_logger(__name__)
|
||
|
||
_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.
|
||
SIZES = {"thumb": (400, 600), "art": (1280, 720)}
|
||
|
||
|
||
def key_for(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 = by_rating_key(db, PlexItem, rating_key)
|
||
if it is not None:
|
||
return it.art_key if variant == "art" else it.thumb_key
|
||
sh = by_rating_key(db, PlexShow, rating_key)
|
||
if sh is not None:
|
||
return sh.art_key if variant == "art" else sh.thumb_key
|
||
se = by_rating_key(db, PlexSeason, rating_key)
|
||
if se is not None:
|
||
return se.thumb_key
|
||
col = by_rating_key(db, PlexCollection, rating_key)
|
||
if col is not None:
|
||
return col.thumb_key
|
||
return None
|
||
|
||
|
||
def read(key: str) -> tuple[bytes, str] | None:
|
||
for ext, ct in _EXT_CT:
|
||
p = CACHE_DIR / f"{key}.{ext}"
|
||
try:
|
||
if p.exists() and p.stat().st_size > 0:
|
||
return p.read_bytes(), ct
|
||
# silent-ok: a miss. The caller fetches from Plex and writes the file again, and the write
|
||
# path below is the one that reports a cache that cannot be used.
|
||
except OSError:
|
||
pass
|
||
return None
|
||
|
||
|
||
def has(key: str) -> bool:
|
||
"""A cached, non-empty file exists for `key` (a prefetch's cheap check — no read)."""
|
||
for ext, _ in _EXT_CT:
|
||
try:
|
||
if (CACHE_DIR / f"{key}.{ext}").stat().st_size > 0:
|
||
return True
|
||
# silent-ok: a miss, as in read().
|
||
except OSError:
|
||
pass
|
||
return False
|
||
|
||
|
||
def drop(key: str) -> None:
|
||
"""Remove `key`'s file, whatever its extension (a superseded variant). Best-effort."""
|
||
for ext, _ in _EXT_CT:
|
||
try:
|
||
(CACHE_DIR / f"{key}.{ext}").unlink(missing_ok=True)
|
||
# silent-ok: a leftover original only costs disk; the small twin is already written.
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def mark_miss(key: str) -> None:
|
||
"""Remember that `key`'s source could not be fetched (an empty `.miss` file; its mtime is when), so
|
||
a prefetch can leave a dead source alone for a while. Best-effort."""
|
||
try:
|
||
CACHE_DIR.mkdir(parents=True, exist_ok=True)
|
||
(CACHE_DIR / f"{key}.miss").touch()
|
||
# silent-ok: without the mark the dead source is only asked for again on the next run.
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def missed_within(key: str, age: timedelta) -> bool:
|
||
"""`key` was marked as a miss less than `age` ago."""
|
||
try:
|
||
mtime = (CACHE_DIR / f"{key}.miss").stat().st_mtime
|
||
# silent-ok: no mark (the usual case).
|
||
except OSError:
|
||
return False
|
||
return time.time() - mtime < age.total_seconds()
|
||
|
||
|
||
def write(key: str, data: bytes, ct: str) -> None:
|
||
ext = _CT_EXT.get((ct or "").split(";")[0].strip(), "jpg")
|
||
try:
|
||
CACHE_DIR.mkdir(parents=True, exist_ok=True)
|
||
tmp = CACHE_DIR / f"{key}.{ext}.tmp"
|
||
tmp.write_bytes(data)
|
||
tmp.replace(CACHE_DIR / f"{key}.{ext}") # atomic publish
|
||
except OSError as exc:
|
||
# Best-effort, and silently so: with an unwritable cache every poster on every grid goes
|
||
# to Plex live, for as long as nobody notices. Debug, because a grid is ~100 images and
|
||
# the point is the condition, not the count.
|
||
log.debug(
|
||
"the Plex image cache could not be written",
|
||
extra=logs.event("plex.imgcache.write_failed", reason=type(exc).__name__),
|
||
)
|
||
|
||
|
||
def response(data: bytes, ct: str) -> Response:
|
||
return Response(content=data, media_type=ct, headers={"Cache-Control": "public, max-age=86400"})
|