mirror of
https://github.com/Benexl/FastAnime.git
synced 2025-12-28 05:33:12 -08:00
251 lines
8.1 KiB
Python
251 lines
8.1 KiB
Python
import logging
|
|
from datetime import datetime
|
|
from typing import List, Optional
|
|
|
|
from ..types import (
|
|
AiringSchedule,
|
|
MediaImage,
|
|
MediaItem,
|
|
MediaSearchResult,
|
|
MediaTag,
|
|
MediaTitle,
|
|
MediaTrailer,
|
|
PageInfo,
|
|
Studio,
|
|
UserListStatus,
|
|
UserProfile,
|
|
)
|
|
from .types import (
|
|
AnilistBaseMediaDataSchema,
|
|
AnilistCurrentlyLoggedInUser,
|
|
AnilistDataSchema,
|
|
AnilistImage,
|
|
AnilistMediaList,
|
|
AnilistMediaLists,
|
|
AnilistMediaNextAiringEpisode,
|
|
AnilistMediaTag,
|
|
AnilistMediaTitle,
|
|
AnilistMediaTrailer,
|
|
AnilistPageInfo,
|
|
AnilistStudioNodes,
|
|
AnilistViewerData,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _to_generic_media_title(anilist_title: AnilistMediaTitle) -> MediaTitle:
|
|
"""Maps an AniList title object to a generic MediaTitle."""
|
|
return MediaTitle(
|
|
romaji=anilist_title.get("romaji"),
|
|
english=anilist_title.get("english"),
|
|
native=anilist_title.get("native"),
|
|
)
|
|
|
|
|
|
def _to_generic_media_image(anilist_image: AnilistImage) -> MediaImage:
|
|
"""Maps an AniList image object to a generic MediaImage."""
|
|
return MediaImage(
|
|
medium=anilist_image.get("medium"),
|
|
large=anilist_image["large"],
|
|
extra_large=anilist_image.get("extraLarge"),
|
|
)
|
|
|
|
|
|
def _to_generic_media_trailer(
|
|
anilist_trailer: Optional[AnilistMediaTrailer],
|
|
) -> Optional[MediaTrailer]:
|
|
"""Maps an AniList trailer object to a generic MediaTrailer."""
|
|
if not anilist_trailer or not anilist_trailer.get("id"):
|
|
return None
|
|
return MediaTrailer(
|
|
id=anilist_trailer["id"],
|
|
site=anilist_trailer.get("site"),
|
|
thumbnail_url=anilist_trailer.get("thumbnail"),
|
|
)
|
|
|
|
|
|
def _to_generic_airing_schedule(
|
|
anilist_schedule: AnilistMediaNextAiringEpisode,
|
|
) -> Optional[AiringSchedule]:
|
|
"""Maps an AniList nextAiringEpisode object to a generic AiringSchedule."""
|
|
if not anilist_schedule:
|
|
return
|
|
|
|
return AiringSchedule(
|
|
airing_at=datetime.fromtimestamp(anilist_schedule["airingAt"])
|
|
if anilist_schedule.get("airingAt")
|
|
else None,
|
|
episode=anilist_schedule.get("episode", 0),
|
|
)
|
|
|
|
|
|
def _to_generic_studios(anilist_studios: AnilistStudioNodes) -> List[Studio]:
|
|
"""Maps AniList studio nodes to a list of generic Studio objects."""
|
|
return [
|
|
Studio(
|
|
name=s["name"],
|
|
favourites=s["favourites"],
|
|
is_animation_studio=s["isAnimationStudio"],
|
|
)
|
|
for s in anilist_studios["nodes"]
|
|
]
|
|
|
|
|
|
def _to_generic_tags(anilist_tags: list[AnilistMediaTag]) -> List[MediaTag]:
|
|
"""Maps a list of AniList tags to generic MediaTag objects."""
|
|
return [
|
|
MediaTag(name=t["name"], rank=t.get("rank"))
|
|
for t in anilist_tags
|
|
if t.get("name")
|
|
]
|
|
|
|
|
|
def _to_generic_user_status(
|
|
anilist_media: AnilistBaseMediaDataSchema,
|
|
anilist_list_entry: Optional[AnilistMediaList],
|
|
) -> Optional[UserListStatus]:
|
|
"""Maps an AniList mediaListEntry to a generic UserListStatus."""
|
|
if anilist_list_entry:
|
|
return UserListStatus(
|
|
status=anilist_list_entry["status"],
|
|
progress=anilist_list_entry["progress"],
|
|
score=anilist_list_entry["score"],
|
|
repeat=anilist_list_entry["repeat"],
|
|
notes=anilist_list_entry["notes"],
|
|
start_date=datetime(
|
|
anilist_list_entry["startDate"]["year"],
|
|
anilist_list_entry["startDate"]["month"],
|
|
anilist_list_entry["startDate"]["day"],
|
|
),
|
|
completed_at=datetime(
|
|
anilist_list_entry["completedAt"]["year"],
|
|
anilist_list_entry["completedAt"]["month"],
|
|
anilist_list_entry["completedAt"]["day"],
|
|
),
|
|
created_at=anilist_list_entry["createdAt"],
|
|
)
|
|
else:
|
|
if not anilist_media["mediaListEntry"]:
|
|
return
|
|
return UserListStatus(
|
|
id=anilist_media["mediaListEntry"]["id"],
|
|
status=anilist_media["mediaListEntry"]["status"],
|
|
progress=anilist_media["mediaListEntry"]["progress"],
|
|
)
|
|
|
|
|
|
def _to_generic_media_item(
|
|
data: AnilistBaseMediaDataSchema, media_list: AnilistMediaList | None = None
|
|
) -> MediaItem:
|
|
"""Maps a single AniList media schema to a generic MediaItem."""
|
|
return MediaItem(
|
|
id=data["id"],
|
|
id_mal=data.get("idMal"),
|
|
type=data.get("type", "ANIME"),
|
|
title=_to_generic_media_title(data["title"]),
|
|
status=data["status"],
|
|
format=data.get("format"),
|
|
cover_image=_to_generic_media_image(data["coverImage"]),
|
|
banner_image=data.get("bannerImage"),
|
|
trailer=_to_generic_media_trailer(data["trailer"]),
|
|
description=data.get("description"),
|
|
episodes=data.get("episodes"),
|
|
duration=data.get("duration"),
|
|
genres=data.get("genres", []),
|
|
tags=_to_generic_tags(data.get("tags")),
|
|
studios=_to_generic_studios(data.get("studios")),
|
|
synonyms=data.get("synonyms", []),
|
|
average_score=data.get("averageScore"),
|
|
popularity=data.get("popularity"),
|
|
favourites=data.get("favourites"),
|
|
next_airing=_to_generic_airing_schedule(data.get("nextAiringEpisode")),
|
|
user_status=_to_generic_user_status(data, media_list),
|
|
)
|
|
|
|
|
|
def _to_generic_page_info(data: AnilistPageInfo) -> PageInfo:
|
|
"""Maps an AniList page info object to a generic PageInfo."""
|
|
return PageInfo(
|
|
total=data.get("total", 0),
|
|
current_page=data.get("currentPage", 1),
|
|
has_next_page=data.get("hasNextPage", False),
|
|
per_page=data.get("perPage", 0),
|
|
)
|
|
|
|
|
|
def to_generic_search_result(
|
|
data: AnilistDataSchema, user_media_list: List[AnilistMediaList] | None = None
|
|
) -> Optional[MediaSearchResult]:
|
|
"""
|
|
Top-level mapper to convert a raw AniList search/list API response
|
|
into a generic MediaSearchResult object.
|
|
"""
|
|
page_data = data["data"]["Page"]
|
|
|
|
raw_media_list = page_data["media"]
|
|
if user_media_list:
|
|
media_items: List[MediaItem] = [
|
|
_to_generic_media_item(item, user_media_list_item)
|
|
for item, user_media_list_item in zip(raw_media_list, user_media_list)
|
|
]
|
|
else:
|
|
media_items: List[MediaItem] = [
|
|
_to_generic_media_item(item) for item in raw_media_list
|
|
]
|
|
page_info = _to_generic_page_info(page_data["pageInfo"])
|
|
|
|
return MediaSearchResult(page_info=page_info, media=media_items)
|
|
|
|
|
|
def to_generic_user_list_result(data: AnilistMediaLists) -> Optional[MediaSearchResult]:
|
|
"""
|
|
Mapper for user list queries where media data is nested inside a 'mediaList' key.
|
|
"""
|
|
page_data = data["data"]["Page"]
|
|
|
|
# Extract media objects from the 'mediaList' array
|
|
media_list_items = page_data["mediaList"]
|
|
raw_media_list = [item["media"] for item in media_list_items]
|
|
|
|
# Now that we have a standard list of media, we can reuse the main search result mapper
|
|
return to_generic_search_result(
|
|
{"data": {"Page": {"media": raw_media_list}}}, # pyright:ignore
|
|
media_list_items,
|
|
)
|
|
|
|
|
|
def to_generic_user_profile(data: AnilistViewerData) -> Optional[UserProfile]:
|
|
"""Maps a raw AniList viewer response to a generic UserProfile."""
|
|
|
|
viewer_data: Optional[AnilistCurrentlyLoggedInUser] = data["data"]["Viewer"]
|
|
|
|
return UserProfile(
|
|
id=viewer_data["id"],
|
|
name=viewer_data["name"],
|
|
avatar_url=viewer_data["avatar"]["large"],
|
|
banner_url=viewer_data["bannerImage"],
|
|
)
|
|
|
|
|
|
# TODO: complete this
|
|
def to_generic_relations(data: dict) -> Optional[List[MediaItem]]:
|
|
"""Maps the 'relations' part of an API response."""
|
|
nodes = data["data"].get("Media", {}).get("relations", {}).get("nodes", [])
|
|
return [_to_generic_media_item(node) for node in nodes if node]
|
|
|
|
|
|
def to_generic_recommendations(data: dict) -> Optional[List[MediaItem]]:
|
|
"""Maps the 'recommendations' part of an API response."""
|
|
recs = (
|
|
data.get("data", {})
|
|
.get("Media", {})
|
|
.get("recommendations", {})
|
|
.get("nodes", [])
|
|
)
|
|
return [
|
|
_to_generic_media_item(rec.get("mediaRecommendation"))
|
|
for rec in recs
|
|
if rec.get("mediaRecommendation")
|
|
]
|