NixReaperandClaude Sonnet 5
0ab31a314c
Builds on the accounts foundation: PUT/DELETE a rating (0.5-10.0) or a
watchlist entry on any movie or series, all scoped to the bearer token's
own user, plus GET /account/ratings|watchlist/{movies,series} to list
them back. Both are polymorphic entity_type/entity_id tables, same shape
as watch_provider_offerings and trending_entries, so movie and series
share one repository/router each rather than duplicating per type.
Co-Authored-By: Claude Sonnet 5 <[email protected]>
392 lines
15 KiB
Python
392 lines
15 KiB
Python
"""Assembles Movie API responses from repository data."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import uuid
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.core.ids import aurora_id, parse_aurora_id
|
|
from app.models.enums import ArtworkType, MovieStatus
|
|
from app.models.movie import Movie
|
|
from app.repositories import (
|
|
movie_repository,
|
|
polymorphic,
|
|
rating_repository,
|
|
trending_repository,
|
|
watchlist_repository,
|
|
)
|
|
from app.schemas.account import RatingOut
|
|
from app.schemas.common import CollectionBriefOut, CompanyBriefOut, GenreOut, KeywordOut
|
|
from app.schemas.movie import (
|
|
MovieCreditsOut,
|
|
MovieDetailOut,
|
|
MovieImagesOut,
|
|
MovieListOut,
|
|
MovieRecommendationsOut,
|
|
MovieSummaryOut,
|
|
MovieVideosOut,
|
|
MovieWatchProvidersOut,
|
|
RatedMovieListOut,
|
|
RatedMovieOut,
|
|
)
|
|
from app.services.common import (
|
|
build_watch_providers_out,
|
|
pick_certification,
|
|
primary_artwork_path,
|
|
split_credits,
|
|
to_alternate_title_out,
|
|
to_images_out,
|
|
to_release_date_out,
|
|
to_video_out,
|
|
)
|
|
|
|
|
|
class MovieNotFoundError(Exception):
|
|
pass
|
|
|
|
|
|
class InvalidMovieFilterError(Exception):
|
|
pass
|
|
|
|
|
|
async def _resolve_movie_id(movie_aurora_id: str) -> uuid.UUID:
|
|
try:
|
|
return uuid.UUID(parse_aurora_id(movie_aurora_id, expected_type="movie"))
|
|
except ValueError as exc:
|
|
raise MovieNotFoundError(str(exc)) from exc
|
|
|
|
|
|
async def get_movie_detail(session: AsyncSession, movie_aurora_id: str) -> MovieDetailOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
|
|
genres = await movie_repository.get_movie_genres(session, movie_id)
|
|
keywords = await movie_repository.get_movie_keywords(session, movie_id)
|
|
alternate_titles = await movie_repository.get_movie_alternate_titles(session, movie_id)
|
|
companies = await movie_repository.get_movie_companies(session, movie_id)
|
|
credits_ = await polymorphic.get_credits(session, "movie", movie_id)
|
|
artwork = await polymorphic.get_artwork(session, "movie", movie_id)
|
|
videos = await polymorphic.get_videos(session, "movie", movie_id)
|
|
release_dates = await polymorphic.get_release_dates(session, "movie", movie_id)
|
|
watch_provider_rows = await polymorphic.get_watch_providers(session, "movie", movie_id)
|
|
external_ids = await polymorphic.get_external_ids(session, "movie", movie_id)
|
|
|
|
cast, crew = split_credits(credits_)
|
|
|
|
collection_out: CollectionBriefOut | None = None
|
|
if movie.collection is not None:
|
|
collection_posters = await polymorphic.get_artwork(
|
|
session, "collection", movie.collection.id, ArtworkType.POSTER
|
|
)
|
|
collection_out = CollectionBriefOut(
|
|
id=aurora_id("collection", str(movie.collection.id)),
|
|
name=movie.collection.name,
|
|
poster_path=primary_artwork_path(collection_posters, ArtworkType.POSTER),
|
|
)
|
|
|
|
company_out: list[CompanyBriefOut] = []
|
|
for company, _role in companies:
|
|
logos = await polymorphic.get_artwork(session, "company", company.id, ArtworkType.LOGO)
|
|
company_out.append(
|
|
CompanyBriefOut(
|
|
id=aurora_id("company", str(company.id)),
|
|
name=company.name,
|
|
company_type=company.company_type.value,
|
|
logo_path=primary_artwork_path(logos, ArtworkType.LOGO),
|
|
)
|
|
)
|
|
|
|
return MovieDetailOut(
|
|
id=aurora_id("movie", str(movie.id)),
|
|
title=movie.title,
|
|
original_title=movie.original_title,
|
|
overview=movie.overview,
|
|
tagline=movie.tagline,
|
|
status=movie.status.value,
|
|
original_language=movie.original_language_code,
|
|
release_date=movie.primary_release_date,
|
|
runtime=movie.runtime_minutes,
|
|
budget=movie.budget,
|
|
revenue=movie.revenue,
|
|
popularity=movie.popularity,
|
|
vote_average=movie.vote_average,
|
|
vote_count=movie.vote_count,
|
|
adult=movie.adult,
|
|
certification=pick_certification(release_dates),
|
|
genres=[GenreOut(id=aurora_id("genre", str(g.id)), name=g.name) for g in genres],
|
|
keywords=[KeywordOut(id=aurora_id("keyword", str(k.id)), name=k.name) for k in keywords],
|
|
alternate_titles=[to_alternate_title_out(t) for t in alternate_titles],
|
|
cast=cast,
|
|
crew=crew,
|
|
companies=company_out,
|
|
collection=collection_out,
|
|
images=to_images_out(artwork),
|
|
videos=[to_video_out(v) for v in videos],
|
|
release_dates=[to_release_date_out(rd) for rd in release_dates],
|
|
watch_providers=await build_watch_providers_out(session, watch_provider_rows),
|
|
external_ids=external_ids,
|
|
created_at=movie.created_at,
|
|
updated_at=movie.updated_at,
|
|
)
|
|
|
|
|
|
async def get_movie_credits(session: AsyncSession, movie_aurora_id: str) -> MovieCreditsOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
credits_ = await polymorphic.get_credits(session, "movie", movie_id)
|
|
cast, crew = split_credits(credits_)
|
|
return MovieCreditsOut(id=aurora_id("movie", str(movie.id)), cast=cast, crew=crew)
|
|
|
|
|
|
async def get_movie_images(session: AsyncSession, movie_aurora_id: str) -> MovieImagesOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
artwork = await polymorphic.get_artwork(session, "movie", movie_id)
|
|
return MovieImagesOut(id=aurora_id("movie", str(movie.id)), images=to_images_out(artwork))
|
|
|
|
|
|
async def get_movie_videos(session: AsyncSession, movie_aurora_id: str) -> MovieVideosOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
videos = await polymorphic.get_videos(session, "movie", movie_id)
|
|
return MovieVideosOut(id=aurora_id("movie", str(movie.id)), videos=[to_video_out(v) for v in videos])
|
|
|
|
|
|
async def get_movie_watch_providers(
|
|
session: AsyncSession, movie_aurora_id: str
|
|
) -> MovieWatchProvidersOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
rows = await polymorphic.get_watch_providers(session, "movie", movie_id)
|
|
return MovieWatchProvidersOut(
|
|
id=aurora_id("movie", str(movie.id)), results=await build_watch_providers_out(session, rows)
|
|
)
|
|
|
|
|
|
async def get_movie_recommendations(
|
|
session: AsyncSession, movie_aurora_id: str
|
|
) -> MovieRecommendationsOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
recommended_ids = await movie_repository.get_movie_recommendation_ids(session, movie_id)
|
|
summaries = await build_movie_summaries(session, recommended_ids)
|
|
return MovieRecommendationsOut(id=aurora_id("movie", str(movie.id)), recommendations=summaries)
|
|
|
|
|
|
async def _movie_summary_from_row(session: AsyncSession, movie: Movie) -> MovieSummaryOut:
|
|
posters = await polymorphic.get_artwork(session, "movie", movie.id, ArtworkType.POSTER)
|
|
return MovieSummaryOut(
|
|
id=aurora_id("movie", str(movie.id)),
|
|
title=movie.title,
|
|
original_title=movie.original_title,
|
|
overview=movie.overview,
|
|
release_date=movie.primary_release_date,
|
|
poster_path=primary_artwork_path(posters, ArtworkType.POSTER),
|
|
popularity=movie.popularity,
|
|
vote_average=movie.vote_average,
|
|
)
|
|
|
|
|
|
async def build_movie_summary(session: AsyncSession, movie_id: uuid.UUID) -> MovieSummaryOut | None:
|
|
movie = await movie_repository.get_movie_by_id(session, movie_id)
|
|
if movie is None:
|
|
return None
|
|
return await _movie_summary_from_row(session, movie)
|
|
|
|
|
|
async def build_movie_summaries(
|
|
session: AsyncSession, movie_ids: list[uuid.UUID]
|
|
) -> list[MovieSummaryOut]:
|
|
out: list[MovieSummaryOut] = []
|
|
for movie_id in movie_ids:
|
|
summary = await build_movie_summary(session, movie_id)
|
|
if summary is not None:
|
|
out.append(summary)
|
|
return out
|
|
|
|
|
|
async def rate_movie(
|
|
session: AsyncSession, movie_aurora_id: str, *, user_id: uuid.UUID, value: float
|
|
) -> RatingOut:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
if await movie_repository.get_movie_by_id(session, movie_id) is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
|
|
rating = await rating_repository.upsert_rating(
|
|
session, user_id=user_id, entity_type="movie", entity_id=movie_id, value=value
|
|
)
|
|
return RatingOut(value=rating.value, created_at=rating.created_at, updated_at=rating.updated_at)
|
|
|
|
|
|
async def unrate_movie(session: AsyncSession, movie_aurora_id: str, *, user_id: uuid.UUID) -> None:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
if await movie_repository.get_movie_by_id(session, movie_id) is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
|
|
await rating_repository.delete_rating(session, user_id=user_id, entity_type="movie", entity_id=movie_id)
|
|
|
|
|
|
async def list_rated_movies(
|
|
session: AsyncSession, *, user_id: uuid.UUID, page: int, page_size: int
|
|
) -> RatedMovieListOut:
|
|
ratings, total = await rating_repository.list_rated(
|
|
session, user_id=user_id, entity_type="movie", limit=page_size, offset=(page - 1) * page_size
|
|
)
|
|
results: list[RatedMovieOut] = []
|
|
for rating in ratings:
|
|
summary = await build_movie_summary(session, rating.entity_id)
|
|
if summary is not None:
|
|
results.append(RatedMovieOut(**summary.model_dump(), rating=rating.value))
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
|
|
return RatedMovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|
|
|
|
|
|
async def add_movie_to_watchlist(
|
|
session: AsyncSession, movie_aurora_id: str, *, user_id: uuid.UUID
|
|
) -> None:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
if await movie_repository.get_movie_by_id(session, movie_id) is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
|
|
await watchlist_repository.add_entry(session, user_id=user_id, entity_type="movie", entity_id=movie_id)
|
|
|
|
|
|
async def remove_movie_from_watchlist(
|
|
session: AsyncSession, movie_aurora_id: str, *, user_id: uuid.UUID
|
|
) -> None:
|
|
movie_id = await _resolve_movie_id(movie_aurora_id)
|
|
if await movie_repository.get_movie_by_id(session, movie_id) is None:
|
|
raise MovieNotFoundError(movie_aurora_id)
|
|
|
|
await watchlist_repository.remove_entry(session, user_id=user_id, entity_type="movie", entity_id=movie_id)
|
|
|
|
|
|
async def list_watchlist_movies(
|
|
session: AsyncSession, *, user_id: uuid.UUID, page: int, page_size: int
|
|
) -> MovieListOut:
|
|
entries, total = await watchlist_repository.list_entries(
|
|
session, user_id=user_id, entity_type="movie", limit=page_size, offset=(page - 1) * page_size
|
|
)
|
|
results = await build_movie_summaries(session, [entry.entity_id for entry in entries])
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
|
|
return MovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|
|
|
|
|
|
async def list_now_playing(
|
|
session: AsyncSession, *, region: str, page: int, page_size: int
|
|
) -> MovieListOut:
|
|
movies, total = await movie_repository.list_now_playing(
|
|
session, region=region.upper(), limit=page_size, offset=(page - 1) * page_size
|
|
)
|
|
results = [await _movie_summary_from_row(session, m) for m in movies]
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
return MovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|
|
|
|
|
|
async def list_upcoming(session: AsyncSession, *, region: str, page: int, page_size: int) -> MovieListOut:
|
|
movies, total = await movie_repository.list_upcoming(
|
|
session, region=region.upper(), limit=page_size, offset=(page - 1) * page_size
|
|
)
|
|
results = [await _movie_summary_from_row(session, m) for m in movies]
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
return MovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|
|
|
|
|
|
_TRENDING_WINDOWS = ("day", "week")
|
|
|
|
|
|
async def list_trending(
|
|
session: AsyncSession, *, time_window: str, page: int, page_size: int
|
|
) -> MovieListOut:
|
|
if time_window not in _TRENDING_WINDOWS:
|
|
raise InvalidMovieFilterError(f"unknown time_window: {time_window!r}")
|
|
|
|
all_ids = await trending_repository.get_trending_entity_ids(
|
|
session, entity_type="movie", time_window=time_window
|
|
)
|
|
total = len(all_ids)
|
|
start = (page - 1) * page_size
|
|
page_ids = all_ids[start : start + page_size]
|
|
movies = await movie_repository.get_movies_by_ids(session, page_ids)
|
|
results = [await _movie_summary_from_row(session, m) for m in movies]
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
|
|
return MovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|
|
|
|
|
|
async def list_movies(
|
|
session: AsyncSession,
|
|
*,
|
|
genre_aurora_id: str | None,
|
|
keyword_aurora_id: str | None,
|
|
year: int | None,
|
|
status: str | None,
|
|
sort_by: str,
|
|
sort_dir: str,
|
|
page: int,
|
|
page_size: int,
|
|
) -> MovieListOut:
|
|
genre_id: uuid.UUID | None = None
|
|
if genre_aurora_id is not None:
|
|
try:
|
|
genre_id = uuid.UUID(parse_aurora_id(genre_aurora_id, expected_type="genre"))
|
|
except ValueError as exc:
|
|
raise InvalidMovieFilterError(f"invalid genre id: {genre_aurora_id!r}") from exc
|
|
|
|
keyword_id: uuid.UUID | None = None
|
|
if keyword_aurora_id is not None:
|
|
try:
|
|
keyword_id = uuid.UUID(parse_aurora_id(keyword_aurora_id, expected_type="keyword"))
|
|
except ValueError as exc:
|
|
raise InvalidMovieFilterError(f"invalid keyword id: {keyword_aurora_id!r}") from exc
|
|
|
|
status_enum: MovieStatus | None = None
|
|
if status is not None:
|
|
try:
|
|
status_enum = MovieStatus(status)
|
|
except ValueError as exc:
|
|
raise InvalidMovieFilterError(f"unknown movie status: {status!r}") from exc
|
|
|
|
movies, total = await movie_repository.list_movies(
|
|
session,
|
|
genre_id=genre_id,
|
|
keyword_id=keyword_id,
|
|
year=year,
|
|
status=status_enum,
|
|
sort_by=sort_by,
|
|
sort_dir=sort_dir,
|
|
limit=page_size,
|
|
offset=(page - 1) * page_size,
|
|
)
|
|
results = [await _movie_summary_from_row(session, m) for m in movies]
|
|
total_pages = (total + page_size - 1) // page_size if total else 0
|
|
|
|
return MovieListOut(
|
|
page=page, page_size=page_size, total_results=total, total_pages=total_pages, results=results
|
|
)
|