299 lines
9.7 KiB
Python
299 lines
9.7 KiB
Python
"""CLI command for NFO management.
|
|
|
|
This script provides command-line interface for creating, updating,
|
|
and checking NFO metadata files.
|
|
"""
|
|
|
|
import asyncio
|
|
import logging
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
# Add src to path
|
|
sys.path.insert(0, str(Path(__file__).parent.parent.parent))
|
|
|
|
from src.config.settings import settings
|
|
from src.core.services.series_manager_service import SeriesManagerService
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def scan_and_create_nfo():
|
|
"""Scan all series and create missing NFO files."""
|
|
logger.info("%s", "=" * 70)
|
|
logger.info("NFO Auto-Creation Tool")
|
|
logger.info("%s", "=" * 70)
|
|
|
|
if not settings.tmdb_api_key:
|
|
logger.error("TMDB_API_KEY not configured")
|
|
logger.error("Set TMDB_API_KEY in .env file or environment")
|
|
logger.error("Get API key from: https://www.themoviedb.org/settings/api")
|
|
return 1
|
|
|
|
if not settings.anime_directory:
|
|
logger.error("ANIME_DIRECTORY not configured")
|
|
return 1
|
|
|
|
logger.info("Anime Directory: %s", settings.anime_directory)
|
|
logger.info("Auto-create NFO: %s", settings.nfo_auto_create)
|
|
logger.info("Update on scan: %s", settings.nfo_update_on_scan)
|
|
logger.info("Download poster: %s", settings.nfo_download_poster)
|
|
logger.info("Download logo: %s", settings.nfo_download_logo)
|
|
logger.info("Download fanart: %s", settings.nfo_download_fanart)
|
|
|
|
if not settings.nfo_auto_create:
|
|
logger.warning("NFO_AUTO_CREATE is set to False")
|
|
logger.warning("Enable it in .env to auto-create NFO files")
|
|
logger.info("Continuing anyway to demonstrate functionality...")
|
|
# Override for demonstration
|
|
settings.nfo_auto_create = True
|
|
|
|
logger.info("Initializing series manager...")
|
|
manager = SeriesManagerService.from_settings()
|
|
|
|
# Get series list first
|
|
serie_list = manager.get_serie_list()
|
|
all_series = serie_list.get_all()
|
|
|
|
logger.info("Found %d series in directory", len(all_series))
|
|
|
|
if not all_series:
|
|
logger.warning("No series found. Add some anime series first.")
|
|
return 0
|
|
|
|
# Show series without NFO
|
|
series_without_nfo = []
|
|
for serie in all_series:
|
|
if not serie.has_nfo():
|
|
series_without_nfo.append(serie)
|
|
|
|
if series_without_nfo:
|
|
logger.info("Series without NFO: %d", len(series_without_nfo))
|
|
for serie in series_without_nfo[:5]: # Show first 5
|
|
logger.debug("Missing NFO: %s (%s)", serie.name, serie.folder)
|
|
if len(series_without_nfo) > 5:
|
|
logger.info("... and %d more", len(series_without_nfo) - 5)
|
|
else:
|
|
logger.info("All series already have NFO files")
|
|
|
|
if not settings.nfo_update_on_scan:
|
|
logger.info("Nothing to do. Enable NFO_UPDATE_ON_SCAN to update existing NFOs.")
|
|
return 0
|
|
|
|
logger.info("Processing NFO files...")
|
|
logger.info("This may take a while depending on the number of series")
|
|
|
|
try:
|
|
await manager.scan_and_process_nfo()
|
|
logger.info("NFO processing complete")
|
|
|
|
# Show updated stats
|
|
serie_list.load_series() # Reload to get updated stats
|
|
all_series = serie_list.get_all()
|
|
series_with_nfo = [s for s in all_series if s.has_nfo()]
|
|
series_with_poster = [s for s in all_series if s.has_poster()]
|
|
series_with_logo = [s for s in all_series if s.has_logo()]
|
|
series_with_fanart = [s for s in all_series if s.has_fanart()]
|
|
|
|
logger.info("Final statistics", extra={
|
|
"total_series": len(all_series),
|
|
"with_nfo": len(series_with_nfo),
|
|
"with_poster": len(series_with_poster),
|
|
"with_logo": len(series_with_logo),
|
|
"with_fanart": len(series_with_fanart),
|
|
})
|
|
|
|
except Exception:
|
|
logger.exception("Failed to process NFO files")
|
|
return 1
|
|
finally:
|
|
await manager.close()
|
|
|
|
return 0
|
|
|
|
|
|
async def check_nfo_status():
|
|
"""Check NFO status for all series."""
|
|
logger.info("%s", "=" * 70)
|
|
logger.info("NFO Status Check")
|
|
logger.info("%s", "=" * 70)
|
|
|
|
if not settings.anime_directory:
|
|
logger.error("ANIME_DIRECTORY not configured")
|
|
return 1
|
|
|
|
logger.info("Anime Directory: %s", settings.anime_directory)
|
|
|
|
# Create series list (no NFO service needed for status check)
|
|
from src.core.entities.SerieList import SerieList
|
|
serie_list = SerieList(settings.anime_directory)
|
|
all_series = serie_list.get_all()
|
|
|
|
if not all_series:
|
|
logger.warning("No series found")
|
|
return 0
|
|
|
|
logger.info("Total series: %d", len(all_series))
|
|
|
|
# Categorize series
|
|
with_nfo = []
|
|
without_nfo = []
|
|
|
|
for serie in all_series:
|
|
if serie.has_nfo():
|
|
with_nfo.append(serie)
|
|
else:
|
|
without_nfo.append(serie)
|
|
|
|
logger.info(
|
|
"Series NFO coverage",
|
|
extra={
|
|
"with_nfo": len(with_nfo),
|
|
"without_nfo": len(without_nfo),
|
|
"total": len(all_series),
|
|
},
|
|
)
|
|
|
|
if without_nfo:
|
|
logger.info("Series missing NFO: %d", len(without_nfo))
|
|
for serie in without_nfo[:10]:
|
|
logger.debug("Missing NFO: %s (%s)", serie.name, serie.folder)
|
|
if len(without_nfo) > 10:
|
|
logger.info("... and %d more", len(without_nfo) - 10)
|
|
|
|
# Media file statistics
|
|
with_poster = sum(1 for s in all_series if s.has_poster())
|
|
with_logo = sum(1 for s in all_series if s.has_logo())
|
|
with_fanart = sum(1 for s in all_series if s.has_fanart())
|
|
|
|
logger.info(
|
|
"Media file coverage",
|
|
extra={
|
|
"posters": with_poster,
|
|
"logos": with_logo,
|
|
"fanart": with_fanart,
|
|
"total": len(all_series),
|
|
},
|
|
)
|
|
|
|
return 0
|
|
|
|
|
|
async def update_nfo_files():
|
|
"""Update existing NFO files with fresh data from TMDB."""
|
|
logger.info("%s", "=" * 70)
|
|
logger.info("NFO Update Tool")
|
|
logger.info("%s", "=" * 70)
|
|
|
|
if not settings.tmdb_api_key:
|
|
logger.error("TMDB_API_KEY not configured")
|
|
logger.error("Set TMDB_API_KEY in .env file or environment")
|
|
logger.error("Get API key from: https://www.themoviedb.org/settings/api")
|
|
return 1
|
|
|
|
if not settings.anime_directory:
|
|
logger.error("ANIME_DIRECTORY not configured")
|
|
return 1
|
|
|
|
logger.info("Anime Directory: %s", settings.anime_directory)
|
|
logger.info(
|
|
"Download media: %s",
|
|
settings.nfo_download_poster or settings.nfo_download_logo or settings.nfo_download_fanart,
|
|
)
|
|
|
|
# Get series with NFO
|
|
from src.core.entities.SerieList import SerieList
|
|
serie_list = SerieList(settings.anime_directory)
|
|
all_series = serie_list.get_all()
|
|
series_with_nfo = [s for s in all_series if s.has_nfo()]
|
|
|
|
if not series_with_nfo:
|
|
logger.warning("No series with NFO files found")
|
|
logger.info("Run 'scan' command first to create NFO files")
|
|
return 0
|
|
|
|
logger.info("Found %d series with NFO files", len(series_with_nfo))
|
|
logger.info("Updating NFO files with fresh data from TMDB...")
|
|
logger.info("This may take a while")
|
|
|
|
# Initialize NFO service using factory
|
|
from src.core.services.nfo_factory import create_nfo_service
|
|
try:
|
|
nfo_service = create_nfo_service()
|
|
except ValueError as e:
|
|
logger.error("Error creating NFO service: %s", e)
|
|
return 1
|
|
|
|
success_count = 0
|
|
error_count = 0
|
|
|
|
try:
|
|
for i, serie in enumerate(series_with_nfo, 1):
|
|
logger.info("[%d/%d] Updating: %s", i, len(series_with_nfo), serie.name)
|
|
|
|
try:
|
|
await nfo_service.update_tvshow_nfo(
|
|
serie_folder=serie.folder,
|
|
download_media=(
|
|
settings.nfo_download_poster or
|
|
settings.nfo_download_logo or
|
|
settings.nfo_download_fanart
|
|
),
|
|
)
|
|
logger.info("Updated successfully: %s", serie.name)
|
|
success_count += 1
|
|
|
|
# Small delay to respect API rate limits
|
|
await asyncio.sleep(0.5)
|
|
|
|
except Exception as e:
|
|
logger.exception("Failed to update NFO for %s", serie.name)
|
|
error_count += 1
|
|
|
|
logger.info("%s", "=" * 70)
|
|
logger.info("Update complete")
|
|
logger.info("Success: %d", success_count)
|
|
logger.info("Errors: %d", error_count)
|
|
|
|
except Exception:
|
|
logger.exception("Fatal error during NFO update")
|
|
return 1
|
|
finally:
|
|
await nfo_service.close()
|
|
|
|
return 0
|
|
|
|
|
|
def main():
|
|
"""Main CLI entry point."""
|
|
logging.basicConfig(level=logging.INFO, format="%(message)s")
|
|
|
|
if len(sys.argv) < 2:
|
|
logger.info("NFO Management Tool")
|
|
logger.info("\nUsage:")
|
|
logger.info(" python -m src.cli.nfo_cli scan # Scan and create missing NFO files")
|
|
logger.info(" python -m src.cli.nfo_cli status # Check NFO status for all series")
|
|
logger.info(" python -m src.cli.nfo_cli update # Update existing NFO files with fresh data")
|
|
logger.info("\nConfiguration:")
|
|
logger.info(" Set TMDB_API_KEY in .env file")
|
|
logger.info(" Set NFO_AUTO_CREATE=true to enable auto-creation")
|
|
logger.info(" Set NFO_UPDATE_ON_SCAN=true to update existing NFOs during scan")
|
|
return 1
|
|
|
|
command = sys.argv[1].lower()
|
|
|
|
if command == "scan":
|
|
return asyncio.run(scan_and_create_nfo())
|
|
elif command == "status":
|
|
return asyncio.run(check_nfo_status())
|
|
elif command == "update":
|
|
return asyncio.run(update_nfo_files())
|
|
else:
|
|
logger.error("Unknown command: %s", command)
|
|
logger.info("Use 'scan', 'status', or 'update'")
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|