188 lines
6.5 KiB
Python
188 lines
6.5 KiB
Python
import httpx
|
|
import logging
|
|
import re
|
|
from typing import List, Optional
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from ..db_models import Anime, AnimeTheme, ThemeType
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Shared HTTP client for AnimeThemes API
|
|
_animethemes_client: Optional[httpx.AsyncClient] = None
|
|
|
|
|
|
def _get_animethemes_client() -> httpx.AsyncClient:
|
|
"""Get or create shared HTTP client for AnimeThemes."""
|
|
global _animethemes_client
|
|
if _animethemes_client is None or _animethemes_client.is_closed:
|
|
_animethemes_client = httpx.AsyncClient(
|
|
base_url="https://api.animethemes.moe",
|
|
timeout=30.0,
|
|
)
|
|
return _animethemes_client
|
|
|
|
|
|
class AnimeThemesService:
|
|
"""Service for AnimeThemes API (api.animethemes.moe)."""
|
|
|
|
def __init__(self):
|
|
self.client = _get_animethemes_client()
|
|
|
|
async def _find_anime_slug(self, anime: Anime) -> Optional[str]:
|
|
"""Find AnimeThemes slug by searching anime title."""
|
|
|
|
# Try different title variations
|
|
search_terms = [
|
|
anime.title_english,
|
|
anime.title_russian,
|
|
anime.title_japanese,
|
|
]
|
|
|
|
for term in search_terms:
|
|
if not term:
|
|
continue
|
|
|
|
try:
|
|
response = await self.client.get(
|
|
"/anime",
|
|
params={
|
|
"q": term,
|
|
"include": "animethemes.animethemeentries.videos.audio",
|
|
},
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
data = response.json()
|
|
animes = data.get("anime", [])
|
|
if animes:
|
|
slug = animes[0].get("slug")
|
|
logger.info(f"Found AnimeThemes slug '{slug}' for '{term}'")
|
|
return slug
|
|
except Exception as e:
|
|
logger.warning(f"Failed to search AnimeThemes for '{term}': {e}")
|
|
continue
|
|
|
|
return None
|
|
|
|
async def fetch_themes(self, db: AsyncSession, anime: Anime) -> List[AnimeTheme]:
|
|
"""Fetch themes from AnimeThemes API and sync to DB."""
|
|
|
|
# Always reload anime with themes to avoid lazy loading issues
|
|
result = await db.execute(
|
|
select(Anime)
|
|
.where(Anime.id == anime.id)
|
|
.options(selectinload(Anime.themes))
|
|
)
|
|
anime = result.scalar_one()
|
|
current_themes = anime.themes or []
|
|
|
|
# Find slug if not cached
|
|
if not anime.animethemes_slug:
|
|
logger.info(f"Searching AnimeThemes slug for: {anime.title_english or anime.title_russian}")
|
|
slug = await self._find_anime_slug(anime)
|
|
logger.info(f"Found slug: {slug}")
|
|
if slug:
|
|
anime.animethemes_slug = slug
|
|
await db.commit()
|
|
|
|
if not anime.animethemes_slug:
|
|
logger.warning(f"No AnimeThemes slug found for anime {anime.id}: {anime.title_english or anime.title_russian}")
|
|
return current_themes
|
|
|
|
# Fetch themes from AnimeThemes API
|
|
try:
|
|
response = await self.client.get(
|
|
f"/anime/{anime.animethemes_slug}",
|
|
params={
|
|
"include": "animethemes.animethemeentries.videos.audio,animethemes.song.artists",
|
|
},
|
|
)
|
|
|
|
if response.status_code != 200:
|
|
logger.warning(f"AnimeThemes API returned {response.status_code} for {anime.animethemes_slug}")
|
|
return current_themes
|
|
|
|
data = response.json()
|
|
except Exception as e:
|
|
logger.error(f"Failed to fetch themes from AnimeThemes for {anime.animethemes_slug}: {e}")
|
|
return current_themes
|
|
|
|
anime_data = data.get("anime", {})
|
|
themes_data = anime_data.get("animethemes", [])
|
|
logger.info(f"AnimeThemes API returned {len(themes_data)} themes for {anime.animethemes_slug}")
|
|
|
|
# Build dict of existing themes
|
|
existing_themes = {
|
|
(t.theme_type, t.sequence): t
|
|
for t in current_themes
|
|
}
|
|
|
|
for theme_data in themes_data:
|
|
# Parse theme type and sequence: "OP1", "ED1", etc.
|
|
slug = theme_data.get("slug", "") # e.g., "OP1", "ED1"
|
|
match = re.match(r"(OP|ED)(\d*)", slug)
|
|
if not match:
|
|
continue
|
|
|
|
theme_type = ThemeType.OP if match.group(1) == "OP" else ThemeType.ED
|
|
sequence = int(match.group(2)) if match.group(2) else 1
|
|
|
|
# Get video URL (prioritize audio link, then video link)
|
|
video_url = None
|
|
entries = theme_data.get("animethemeentries", [])
|
|
if entries:
|
|
videos = entries[0].get("videos", [])
|
|
if videos:
|
|
# Try to get audio link first
|
|
audio = videos[0].get("audio")
|
|
if audio:
|
|
video_url = audio.get("link")
|
|
# Fallback to video link
|
|
if not video_url:
|
|
video_url = videos[0].get("link")
|
|
|
|
# Get song info
|
|
song_data = theme_data.get("song", {})
|
|
song_title = song_data.get("title")
|
|
artist = None
|
|
artists = song_data.get("artists", [])
|
|
if artists:
|
|
artist = artists[0].get("name")
|
|
|
|
key = (theme_type, sequence)
|
|
if key in existing_themes:
|
|
# Update existing theme
|
|
theme = existing_themes[key]
|
|
theme.song_title = song_title
|
|
theme.artist = artist
|
|
if video_url:
|
|
theme.animethemes_video_url = video_url
|
|
else:
|
|
# Create new theme
|
|
theme = AnimeTheme(
|
|
anime_id=anime.id,
|
|
theme_type=theme_type,
|
|
sequence=sequence,
|
|
song_title=song_title,
|
|
artist=artist,
|
|
animethemes_video_url=video_url,
|
|
)
|
|
db.add(theme)
|
|
if anime.themes is None:
|
|
anime.themes = []
|
|
anime.themes.append(theme)
|
|
|
|
await db.commit()
|
|
|
|
# Reload anime with themes to get fresh data
|
|
result = await db.execute(
|
|
select(Anime)
|
|
.where(Anime.id == anime.id)
|
|
.options(selectinload(Anime.themes))
|
|
)
|
|
refreshed_anime = result.scalar_one()
|
|
return refreshed_anime.themes
|