Lukas
18d10b44b5
SetupService.run() now checks each anime folder for tvshow.nfo, logo.png, and poster/fanart images instead of using hardcoded defaults. Provider key resolution via search is unchanged.
286 lines
9.7 KiB
Python
286 lines
9.7 KiB
Python
"""Setup service for first-time database initialization.
|
|
|
|
This service runs during initial application setup to:
|
|
1. Scan anime folders in the data directory
|
|
2. Extract title and year from folder names
|
|
3. Create AnimeSeries records in the database
|
|
4. Resolve provider keys via search (if single match found)
|
|
|
|
The run_once logic is handled by the caller (perform_initial_setup)
|
|
via _check_initial_scan_status, not by this service itself.
|
|
"""
|
|
import os
|
|
import re
|
|
from dataclasses import dataclass
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
import structlog
|
|
|
|
from src.config.settings import settings
|
|
from src.server.database.connection import get_db_session
|
|
from src.server.database.service import AnimeSeriesService
|
|
from src.server.utils.dependencies import get_series_app
|
|
|
|
logger = structlog.get_logger(__name__)
|
|
|
|
|
|
@dataclass
|
|
class SeriesProperties:
|
|
"""Filesystem-derived properties for an AnimeSeries."""
|
|
has_nfo: bool = False
|
|
nfo_path: Optional[str] = None
|
|
nfo_created_at: Optional[datetime] = None
|
|
nfo_updated_at: Optional[datetime] = None
|
|
logo_loaded: bool = False
|
|
images_loaded: bool = False
|
|
|
|
|
|
class SetupService:
|
|
"""Service for setup operations during application initialization."""
|
|
|
|
@staticmethod
|
|
def _extract_year_from_folder_name(folder_name: str) -> Optional[int]:
|
|
"""Extract year from folder name if present.
|
|
|
|
Looks for year in format "(YYYY)" at the end of folder name.
|
|
|
|
Args:
|
|
folder_name: The folder name to parse
|
|
|
|
Returns:
|
|
Year as integer if found, None otherwise
|
|
"""
|
|
if not folder_name:
|
|
return None
|
|
|
|
match = re.search(r'\((\d{4})\)', folder_name)
|
|
if match:
|
|
year = int(match.group(1))
|
|
if 1900 <= year <= 2100:
|
|
return year
|
|
return None
|
|
|
|
@staticmethod
|
|
def _extract_title_from_folder_name(folder_name: str) -> str:
|
|
"""Extract title from folder name by removing year suffix.
|
|
|
|
Args:
|
|
folder_name: The folder name to parse
|
|
|
|
Returns:
|
|
Title with year suffix and surrounding whitespace removed
|
|
"""
|
|
return re.sub(r'\s*\(\d{4}\)\s*$', '', folder_name).strip()
|
|
|
|
@staticmethod
|
|
async def _resolve_key_via_search(title: str) -> str:
|
|
"""Resolve provider key by searching for the title.
|
|
|
|
Args:
|
|
title: The title to search for
|
|
|
|
Returns:
|
|
Provider key if exactly one match with same name found,
|
|
empty string otherwise
|
|
"""
|
|
if not title:
|
|
return ""
|
|
|
|
try:
|
|
series_app = get_series_app()
|
|
results = await series_app.search(title)
|
|
|
|
if len(results) == 1:
|
|
result_name = results[0].get('name', '').lower()
|
|
if result_name == title.lower():
|
|
return results[0].get('key', '')
|
|
except Exception as e:
|
|
logger.warning(
|
|
"Provider search failed for folder",
|
|
title=title,
|
|
error=str(e)
|
|
)
|
|
|
|
return ""
|
|
|
|
@staticmethod
|
|
def _check_nfo_file(folder_path: Path) -> tuple[bool, Optional[str], Optional[datetime], Optional[datetime]]:
|
|
"""Check if tvshow.nfo exists and return its metadata.
|
|
|
|
Args:
|
|
folder_path: Path to the series folder
|
|
|
|
Returns:
|
|
Tuple of (has_nfo, nfo_path, nfo_created_at, nfo_updated_at)
|
|
"""
|
|
nfo_path = folder_path / "tvshow.nfo"
|
|
if nfo_path.is_file():
|
|
stat = nfo_path.stat()
|
|
created = datetime.fromtimestamp(stat.st_ctime, tz=timezone.utc)
|
|
updated = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
|
|
return True, str(nfo_path), created, updated
|
|
return False, None, None, None
|
|
|
|
@staticmethod
|
|
def _check_logo_file(folder_path: Path) -> bool:
|
|
"""Check if logo.png exists.
|
|
|
|
Args:
|
|
folder_path: Path to the series folder
|
|
|
|
Returns:
|
|
True if logo.png exists, False otherwise
|
|
"""
|
|
return (folder_path / "logo.png").is_file()
|
|
|
|
@staticmethod
|
|
def _check_image_files(folder_path: Path) -> bool:
|
|
"""Check if any image files (poster, fanart) exist.
|
|
|
|
Args:
|
|
folder_path: Path to the series folder
|
|
|
|
Returns:
|
|
True if any poster.jpg/jpeg/png or fanart.jpg/jpeg/png exists
|
|
"""
|
|
image_extensions = {'.jpg', '.jpeg', '.png'}
|
|
for child in folder_path.iterdir():
|
|
if child.is_file():
|
|
name_lower = child.name.lower()
|
|
if name_lower.startswith(('poster', 'fanart')) and child.suffix.lower() in image_extensions:
|
|
return True
|
|
return False
|
|
|
|
@classmethod
|
|
def _get_series_properties(cls, folder_path: Path) -> SeriesProperties:
|
|
"""Get all filesystem-derived properties for a series folder.
|
|
|
|
Args:
|
|
folder_path: Path to the series folder
|
|
|
|
Returns:
|
|
SeriesProperties with all detected values
|
|
"""
|
|
has_nfo, nfo_path, nfo_created_at, nfo_updated_at = cls._check_nfo_file(folder_path)
|
|
logo_loaded = cls._check_logo_file(folder_path)
|
|
images_loaded = cls._check_image_files(folder_path)
|
|
|
|
return SeriesProperties(
|
|
has_nfo=has_nfo,
|
|
nfo_path=nfo_path,
|
|
nfo_created_at=nfo_created_at,
|
|
nfo_updated_at=nfo_updated_at,
|
|
logo_loaded=logo_loaded,
|
|
images_loaded=images_loaded,
|
|
)
|
|
|
|
@classmethod
|
|
async def run(cls) -> int:
|
|
"""Run the setup service.
|
|
|
|
Scans anime folders, creates AnimeSeries records, and resolves
|
|
provider keys via search. Should only be called after checking
|
|
that initial scan hasn't been completed yet (via _check_initial_scan_status).
|
|
|
|
Returns:
|
|
Number of new series created
|
|
"""
|
|
if not settings.anime_directory:
|
|
logger.info("Anime directory not configured, skipping setup")
|
|
return 0
|
|
|
|
anime_dir = Path(settings.anime_directory)
|
|
if not anime_dir.is_dir():
|
|
logger.info(
|
|
"Anime directory does not exist, skipping setup: %s",
|
|
anime_dir
|
|
)
|
|
return 0
|
|
|
|
logger.info("Running setup service...")
|
|
|
|
created_count = 0
|
|
skipped_existing = 0
|
|
|
|
try:
|
|
series_app = get_series_app()
|
|
|
|
async with get_db_session() as db:
|
|
for folder in anime_dir.iterdir():
|
|
if not folder.is_dir():
|
|
continue
|
|
|
|
folder_name = folder.name
|
|
|
|
# Check if series already exists in DB
|
|
existing = await AnimeSeriesService.get_by_folder(
|
|
db, folder_name
|
|
)
|
|
if existing:
|
|
skipped_existing += 1
|
|
continue
|
|
|
|
# Extract title and year from folder name
|
|
year = cls._extract_year_from_folder_name(folder_name)
|
|
title = cls._extract_title_from_folder_name(folder_name)
|
|
|
|
if not title:
|
|
logger.warning(
|
|
"Could not extract title from folder: %s",
|
|
folder_name
|
|
)
|
|
continue
|
|
|
|
# Resolve key via provider search
|
|
resolved_key = await cls._resolve_key_via_search(title)
|
|
|
|
# Check filesystem properties
|
|
props = cls._get_series_properties(folder)
|
|
|
|
# Create AnimeSeries record
|
|
series = await AnimeSeriesService.create(
|
|
db=db,
|
|
key=resolved_key,
|
|
name=title,
|
|
site="https://aniworld.to",
|
|
folder=folder_name,
|
|
year=year,
|
|
loading_status="completed",
|
|
episodes_loaded=True,
|
|
logo_loaded=props.logo_loaded,
|
|
images_loaded=props.images_loaded,
|
|
has_nfo=props.has_nfo,
|
|
nfo_path=props.nfo_path,
|
|
nfo_created_at=props.nfo_created_at,
|
|
nfo_updated_at=props.nfo_updated_at,
|
|
)
|
|
created_count += 1
|
|
|
|
logger.debug(
|
|
"Created series from folder",
|
|
folder=folder_name,
|
|
title=title,
|
|
year=year,
|
|
key=resolved_key or "(unresolved)",
|
|
has_nfo=props.has_nfo,
|
|
logo_loaded=props.logo_loaded,
|
|
images_loaded=props.images_loaded,
|
|
)
|
|
|
|
logger.info(
|
|
"Setup complete",
|
|
created=created_count,
|
|
skipped_existing=skipped_existing
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(
|
|
"Setup failed",
|
|
error=str(e),
|
|
exc_info=True
|
|
)
|
|
return created_count
|
|
|
|
return created_count |