lukas.pupkalipinski/Aniworld
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: apply pending code updates

Browse Source
This commit is contained in:
Lukas
2026-03-17 11:39:27 +01:00
parent e5fae0a0a2
commit 92bd55ada1
45 changed files with 2236 additions and 2130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
src/cli/nfo_cli.py
View File

@@ -5,6 +5,7 @@ and checking NFO metadata files.
"""
import asyncio
import logging
import sys
from pathlib import Path
@@ -14,48 +15,50 @@ 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."""
print("=" * 70)
print("NFO Auto-Creation Tool")
print("=" * 70)
logger.info("%s", "=" * 70)
logger.info("NFO Auto-Creation Tool")
logger.info("%s", "=" * 70)
if not settings.tmdb_api_key:
print("\n❌ Error: TMDB_API_KEY not configured")
print(" Set TMDB_API_KEY in .env file or environment")
print(" Get API key from: https://www.themoviedb.org/settings/api")
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:
print("\n❌ Error: ANIME_DIRECTORY not configured")
logger.error("ANIME_DIRECTORY not configured")
return 1
print(f"\nAnime Directory: {settings.anime_directory}")
print(f"Auto-create NFO: {settings.nfo_auto_create}")
print(f"Update on scan: {settings.nfo_update_on_scan}")
print(f"Download poster: {settings.nfo_download_poster}")
print(f"Download logo: {settings.nfo_download_logo}")
print(f"Download fanart: {settings.nfo_download_fanart}")
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:
print("\n⚠️ Warning: NFO_AUTO_CREATE is set to False")
print(" Enable it in .env to auto-create NFO files")
print("\n Continuing anyway to demonstrate functionality...")
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
print("\nInitializing series manager...")
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()
print(f"Found {len(all_series)} series in directory")
logger.info("Found %d series in directory", len(all_series))
if not all_series:
print("\n⚠️ No series found. Add some anime series first.")
logger.warning("No series found. Add some anime series first.")
return 0
# Show series without NFO
@@ -65,25 +68,25 @@ async def scan_and_create_nfo():
series_without_nfo.append(serie)
if series_without_nfo:
print(f"\nSeries without NFO: {len(series_without_nfo)}")
logger.info("Series without NFO: %d", len(series_without_nfo))
for serie in series_without_nfo[:5]: # Show first 5
print(f" - {serie.name} ({serie.folder})")
logger.debug("Missing NFO: %s (%s)", serie.name, serie.folder)
if len(series_without_nfo) > 5:
print(f" ... and {len(series_without_nfo) - 5} more")
logger.info("... and %d more", len(series_without_nfo) - 5)
else:
print("\n✅ All series already have NFO files!")
logger.info("All series already have NFO files")
if not settings.nfo_update_on_scan:
print("\nNothing to do. Enable NFO_UPDATE_ON_SCAN to update existing NFOs.")
logger.info("Nothing to do. Enable NFO_UPDATE_ON_SCAN to update existing NFOs.")
return 0
print("\nProcessing NFO files...")
print("(This may take a while depending on the number of series)")
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()
print("\n✅ NFO processing complete!")
logger.info("NFO processing complete")
# Show updated stats
serie_list.load_series() # Reload to get updated stats
all_series = serie_list.get_all()
@@ -91,17 +94,17 @@ async def scan_and_create_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()]
print("\nFinal Statistics:")
print(f" Series with NFO: {len(series_with_nfo)}/{len(all_series)}")
print(f" Series with poster: {len(series_with_poster)}/{len(all_series)}")
print(f" Series with logo: {len(series_with_logo)}/{len(all_series)}")
print(f" Series with fanart: {len(series_with_fanart)}/{len(all_series)}")
except Exception as e:
print(f"\n❌ Error: {e}")
import traceback
traceback.print_exc()
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()
@@ -111,78 +114,92 @@ async def scan_and_create_nfo():
async def check_nfo_status():
"""Check NFO status for all series."""
print("=" * 70)
print("NFO Status Check")
print("=" * 70)
logger.info("%s", "=" * 70)
logger.info("NFO Status Check")
logger.info("%s", "=" * 70)
if not settings.anime_directory:
print("\n❌ Error: ANIME_DIRECTORY not configured")
logger.error("ANIME_DIRECTORY not configured")
return 1
print(f"\nAnime Directory: {settings.anime_directory}")
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:
print("\n⚠️ No series found")
logger.warning("No series found")
return 0
print(f"\nTotal series: {len(all_series)}")
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)
print(f"\nWith NFO: {len(with_nfo)} ({len(with_nfo) * 100 // len(all_series)}%)")
print(f"Without NFO: {len(without_nfo)} ({len(without_nfo) * 100 // len(all_series)}%)")
logger.info(
"Series NFO coverage",
extra={
"with_nfo": len(with_nfo),
"without_nfo": len(without_nfo),
"total": len(all_series),
},
)
if without_nfo:
print("\nSeries missing NFO:")
logger.info("Series missing NFO: %d", len(without_nfo))
for serie in without_nfo[:10]:
print(f" ❌ {serie.name} ({serie.folder})")
logger.debug("Missing NFO: %s (%s)", serie.name, serie.folder)
if len(without_nfo) > 10:
print(f" ... and {len(without_nfo) - 10} more")
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())
print("\nMedia Files:")
print(f" Posters: {with_poster}/{len(all_series)} ({with_poster * 100 // len(all_series)}%)")
print(f" Logos: {with_logo}/{len(all_series)} ({with_logo * 100 // len(all_series)}%)")
print(f" Fanart: {with_fanart}/{len(all_series)} ({with_fanart * 100 // len(all_series)}%)")
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."""
print("=" * 70)
print("NFO Update Tool")
print("=" * 70)
logger.info("%s", "=" * 70)
logger.info("NFO Update Tool")
logger.info("%s", "=" * 70)
if not settings.tmdb_api_key:
print("\n❌ Error: TMDB_API_KEY not configured")
print(" Set TMDB_API_KEY in .env file or environment")
print(" Get API key from: https://www.themoviedb.org/settings/api")
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:
print("\n❌ Error: ANIME_DIRECTORY not configured")
logger.error("ANIME_DIRECTORY not configured")
return 1
print(f"\nAnime Directory: {settings.anime_directory}")
print(f"Download media: {settings.nfo_download_poster or settings.nfo_download_logo or settings.nfo_download_fanart}")
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
@@ -191,57 +208,55 @@ async def update_nfo_files():
series_with_nfo = [s for s in all_series if s.has_nfo()]
if not series_with_nfo:
print("\n⚠️ No series with NFO files found")
print(" Run 'scan' command first to create NFO files")
logger.warning("No series with NFO files found")
logger.info("Run 'scan' command first to create NFO files")
return 0
print(f"\nFound {len(series_with_nfo)} series with NFO files")
print("Updating NFO files with fresh data from TMDB...")
print("(This may take a while)")
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:
print(f"\nError: {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):
print(f"\n[{i}/{len(series_with_nfo)}] Updating: {serie.name}")
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_poster or
settings.nfo_download_logo or
settings.nfo_download_fanart
)
),
)
print(f" ✅ Updated successfully")
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:
print(f" ❌ Error: {e}")
logger.exception("Failed to update NFO for %s", serie.name)
error_count += 1
print("\n" + "=" * 70)
print(f"✅ Update complete!")
print(f" Success: {success_count}")
print(f" Errors: {error_count}")
except Exception as e:
print(f"\n❌ Fatal error: {e}")
import traceback
traceback.print_exc()
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()
@@ -251,20 +266,22 @@ async def update_nfo_files():
def main():
"""Main CLI entry point."""
logging.basicConfig(level=logging.INFO, format="%(message)s")
if len(sys.argv) < 2:
print("NFO Management Tool")
print("\nUsage:")
print(" python -m src.cli.nfo_cli scan # Scan and create missing NFO files")
print(" python -m src.cli.nfo_cli status # Check NFO status for all series")
print(" python -m src.cli.nfo_cli update # Update existing NFO files with fresh data")
print("\nConfiguration:")
print(" Set TMDB_API_KEY in .env file")
print(" Set NFO_AUTO_CREATE=true to enable auto-creation")
print(" Set NFO_UPDATE_ON_SCAN=true to update existing NFOs during scan")
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":
@@ -272,8 +289,8 @@ def main():
elif command == "update":
return asyncio.run(update_nfo_files())
else:
print(f"Unknown command: {command}")
print("Use 'scan', 'status', or 'update'")
logger.error("Unknown command: %s", command)
logger.info("Use 'scan', 'status', or 'update'")
return 1

24
src/core/entities/SerieList.py
View File

@@ -121,11 +121,11 @@ class SerieList:
def load_series(self) -> None:
"""Populate the in-memory map with metadata discovered on disk."""
logging.info("Scanning anime folders in %s", self.directory)
logger.info("Scanning anime folders in %s", self.directory)
try:
entries: Iterable[str] = os.listdir(self.directory)
except OSError as error:
logging.error(
logger.error(
"Unable to scan directory %s: %s",
self.directory,
error,
@@ -145,7 +145,7 @@ class SerieList:
for anime_folder in entries:
anime_path = os.path.join(self.directory, anime_folder, "data")
if os.path.isfile(anime_path):
logging.debug("Found data file for folder %s", anime_folder)
logger.debug("Found data file for folder %s", anime_folder)
serie = self._load_data(anime_folder, anime_path)
if serie:
@@ -159,7 +159,7 @@ class SerieList:
nfo_stats["with_nfo"] += 1
else:
nfo_stats["without_nfo"] += 1
logging.debug(
logger.debug(
"Series '%s' (key: %s) is missing tvshow.nfo",
serie.name,
serie.key
@@ -173,7 +173,7 @@ class SerieList:
media_stats["with_poster"] += 1
else:
media_stats["without_poster"] += 1
logging.debug(
logger.debug(
"Series '%s' (key: %s) is missing poster.jpg",
serie.name,
serie.key
@@ -184,7 +184,7 @@ class SerieList:
media_stats["with_logo"] += 1
else:
media_stats["without_logo"] += 1
logging.debug(
logger.debug(
"Series '%s' (key: %s) is missing logo.png",
serie.name,
serie.key
@@ -195,7 +195,7 @@ class SerieList:
media_stats["with_fanart"] += 1
else:
media_stats["without_fanart"] += 1
logging.debug(
logger.debug(
"Series '%s' (key: %s) is missing fanart.jpg",
serie.name,
serie.key
@@ -203,20 +203,20 @@ class SerieList:
continue
logging.warning(
logger.warning(
"Skipping folder %s because no metadata file was found",
anime_folder,
)
# Log summary statistics
if nfo_stats["total"] > 0:
logging.info(
logger.info(
"NFO scan complete: %d series total, %d with NFO, %d without NFO",
nfo_stats["total"],
nfo_stats["with_nfo"],
nfo_stats["without_nfo"]
)
logging.info(
logger.info(
"Media scan complete: Poster (%d/%d), Logo (%d/%d), Fanart (%d/%d)",
media_stats["with_poster"],
nfo_stats["total"],
@@ -241,14 +241,14 @@ class SerieList:
serie = Serie.load_from_file(data_path)
# Store by key, not folder
self.keyDict[serie.key] = serie
logging.debug(
logger.debug(
"Successfully loaded metadata for %s (key: %s)",
anime_folder,
serie.key
)
return serie
except (OSError, JSONDecodeError, KeyError, ValueError) as error:
logging.error(
logger.error(
"Failed to load metadata for folder %s from %s: %s",
anime_folder,
data_path,

10
src/core/entities/series.py
View File

@@ -64,6 +64,16 @@ class Serie:
f"episodeDict={self.episodeDict}{year_str})"
)
def __repr__(self):
"""Concise developer representation of Serie object."""
season_count = len(self.episodeDict)
episode_count = sum(len(eps) for eps in self.episodeDict.values())
year_str = f", year={self.year}" if self.year else ""
return (
f"Serie(key={self.key!r}, name={self.name!r}"
f"{year_str}, seasons={season_count}, episodes={episode_count})"
)
@property
def key(self) -> str:
"""

21
src/core/error_handler.py
View File

@@ -55,7 +55,8 @@ class RecoveryStrategies:
if attempt == max_retries - 1:
raise
logger.warning(
f"Network error on attempt {attempt + 1}, retrying..."
"Network error on attempt %d, retrying...",
attempt + 1,
)
continue
@@ -72,7 +73,8 @@ class RecoveryStrategies:
if attempt == max_retries - 1:
raise
logger.warning(
f"Download error on attempt {attempt + 1}, retrying..."
"Download error on attempt %d, retrying...",
attempt + 1,
)
continue
@@ -92,7 +94,7 @@ class FileCorruptionDetector:
# Video files should be at least 1MB
return file_size > 1024 * 1024
except Exception as e:
logger.error(f"Error checking file validity: {e}")
logger.error("Error checking file validity: %s", e)
return False
@@ -123,13 +125,18 @@ def with_error_recovery(
last_error = e
if attempt < max_retries - 1:
logger.warning(
f"Error in {context} (attempt {attempt + 1}/"
f"{max_retries}): {e}, retrying..."
"Error in %s (attempt %d/%d): %s, retrying...",
context,
attempt + 1,
max_retries,
e,
)
else:
logger.error(
f"Error in {context} failed after {max_retries} "
f"attempts: {e}"
"Error in %s failed after %d attempts: %s",
context,
max_retries,
e,
)
if last_error:

8
src/core/interfaces/callbacks.py
View File

@@ -12,6 +12,8 @@ from dataclasses import dataclass, field
from enum import Enum
from typing import Any, Dict, Optional
logger = logging.getLogger(__name__)
class OperationType(str, Enum):
"""Types of operations that can report progress."""
@@ -313,7 +315,7 @@ class CallbackManager:
callback.on_progress(context)
except Exception as e:
# Log but don't let callback errors break the operation
logging.error(
logger.error(
"Error in progress callback %s: %s",
callback,
e,
@@ -332,7 +334,7 @@ class CallbackManager:
callback.on_error(context)
except Exception as e:
# Log but don't let callback errors break the operation
logging.error(
logger.error(
"Error in error callback %s: %s",
callback,
e,
@@ -351,7 +353,7 @@ class CallbackManager:
callback.on_completion(context)
except Exception as e:
# Log but don't let callback errors break the operation
logging.error(
logger.error(
"Error in completion callback %s: %s",
callback,
e,

1386
src/core/providers/aniworld_provider.py
View File

File diff suppressed because it is too large Load Diff

12
src/core/providers/config_manager.py
View File

@@ -87,7 +87,7 @@ class ProviderConfigManager:
settings: Provider settings to apply.
"""
self._provider_settings[provider_name] = settings
logger.info(f"Updated settings for provider: {provider_name}")
logger.info("Updated settings for provider: %s", provider_name)
def update_provider_settings(
self, provider_name: str, **kwargs
@@ -106,7 +106,7 @@ class ProviderConfigManager:
self._provider_settings[provider_name] = ProviderSettings(
name=provider_name, **kwargs
)
logger.info(f"Created new settings for provider: {provider_name}") # noqa: E501
logger.info("Created new settings for provider: %s", provider_name) # noqa: E501
return True
settings = self._provider_settings[provider_name]
@@ -152,7 +152,7 @@ class ProviderConfigManager:
"""
if provider_name in self._provider_settings:
self._provider_settings[provider_name].enabled = True
logger.info(f"Enabled provider: {provider_name}")
logger.info("Enabled provider: %s", provider_name)
return True
return False
@@ -167,7 +167,7 @@ class ProviderConfigManager:
"""
if provider_name in self._provider_settings:
self._provider_settings[provider_name].enabled = False
logger.info(f"Disabled provider: {provider_name}")
logger.info("Disabled provider: %s", provider_name)
return True
return False
@@ -224,7 +224,7 @@ class ProviderConfigManager:
value: Setting value.
"""
self._global_settings[key] = value
logger.info(f"Updated global setting {key}: {value}")
logger.info("Updated global setting %s: %s", key, value)
def get_all_global_settings(self) -> Dict[str, Any]:
"""Get all global settings.
@@ -307,7 +307,7 @@ class ProviderConfigManager:
with open(config_path, "w", encoding="utf-8") as f:
json.dump(data, f, indent=2)
logger.info(f"Saved configuration to {config_path}")
logger.info("Saved configuration to %s", config_path)
return True
except Exception as e:

1979
src/core/providers/enhanced_provider.py
View File

File diff suppressed because it is too large Load Diff

2
src/core/providers/failover.py
View File

@@ -207,7 +207,7 @@ class ProviderFailover:
"""
if provider_name not in self._providers:
self._providers.append(provider_name)
logger.info(f"Added provider to failover chain: {provider_name}")
logger.info("Added provider to failover chain: %s", provider_name)
def remove_provider(self, provider_name: str) -> bool:
"""Remove a provider from the failover chain.

6
src/core/providers/health_monitor.py
View File

@@ -151,7 +151,7 @@ class ProviderHealthMonitor:
except asyncio.CancelledError:
break
except Exception as e:
logger.error(f"Error in health check loop: {e}", exc_info=True)
logger.exception("Error in health check loop: %s", e)
await asyncio.sleep(self._health_check_interval)
async def _perform_health_checks(self) -> None:
@@ -314,7 +314,7 @@ class ProviderHealthMonitor:
)
best_provider = available[0][0]
logger.debug(f"Best provider selected: {best_provider}")
logger.debug("Best provider selected: %s", best_provider)
return best_provider
def _get_recent_metrics(
@@ -355,7 +355,7 @@ class ProviderHealthMonitor:
provider_name=provider_name
)
self._request_history[provider_name].clear()
logger.info(f"Reset metrics for provider: {provider_name}")
logger.info("Reset metrics for provider: %s", provider_name)
return True
def get_health_summary(self) -> Dict[str, Any]:

30
src/core/services/nfo_service.py
View File

@@ -134,21 +134,21 @@ class NFOService:
clean_name, extracted_year = self._extract_year_from_name(serie_name)
if year is None and extracted_year is not None:
year = extracted_year
logger.info(f"Extracted year {year} from series name")
logger.info("Extracted year %s from series name", year)
# Use clean name for search
search_name = clean_name
logger.info(f"Creating NFO for {search_name} (year: {year})")
logger.info("Creating NFO for %s (year: %s)", search_name, year)
folder_path = self.anime_directory / serie_folder
if not folder_path.exists():
logger.info(f"Creating series folder: {folder_path}")
logger.info("Creating series folder: %s", folder_path)
folder_path.mkdir(parents=True, exist_ok=True)
async with self.tmdb_client:
# Search for TV show with clean name (without year)
logger.debug(f"Searching TMDB for: {search_name}")
logger.debug("Searching TMDB for: %s", search_name)
search_results = await self.tmdb_client.search_tv_show(search_name)
if not search_results.get("results"):
@@ -158,7 +158,7 @@ class NFOService:
tv_show = self._find_best_match(search_results["results"], search_name, year)
tv_id = tv_show["id"]
logger.info(f"Found match: {tv_show['name']} (ID: {tv_id})")
logger.info("Found match: %s (ID: %s)", tv_show['name'], tv_id)
# Get detailed information with multi-language image support
details = await self.tmdb_client.get_tv_show_details(
@@ -190,7 +190,7 @@ class NFOService:
# Save NFO file
nfo_path = folder_path / "tvshow.nfo"
nfo_path.write_text(nfo_xml, encoding="utf-8")
logger.info(f"Created NFO: {nfo_path}")
logger.info("Created NFO: %s", nfo_path)
# Download media files
await self._download_media_files(
@@ -227,7 +227,7 @@ class NFOService:
if not nfo_path.exists():
raise FileNotFoundError(f"NFO file not found: {nfo_path}")
logger.info(f"Updating NFO for {serie_folder}")
logger.info("Updating NFO for %s", serie_folder)
# Parse existing NFO to extract TMDB ID
try:
@@ -253,7 +253,7 @@ class NFOService:
f"Delete the NFO and create a new one instead."
)
logger.debug(f"Found TMDB ID: {tmdb_id}")
logger.debug("Found TMDB ID: %s", tmdb_id)
except etree.XMLSyntaxError as e:
raise TMDBAPIError(f"Invalid XML in NFO file: {e}")
@@ -262,7 +262,7 @@ class NFOService:
# Fetch fresh data from TMDB
async with self.tmdb_client:
logger.debug(f"Fetching fresh data for TMDB ID: {tmdb_id}")
logger.debug("Fetching fresh data for TMDB ID: %s", tmdb_id)
details = await self.tmdb_client.get_tv_show_details(
tmdb_id,
append_to_response="credits,external_ids,images"
@@ -286,7 +286,7 @@ class NFOService:
# Save updated NFO file
nfo_path.write_text(nfo_xml, encoding="utf-8")
logger.info(f"Updated NFO: {nfo_path}")
logger.info("Updated NFO: %s", nfo_path)
# Re-download media files if requested
if download_media:
@@ -318,7 +318,7 @@ class NFOService:
result = {"tmdb_id": None, "tvdb_id": None}
if not nfo_path.exists():
logger.debug(f"NFO file not found: {nfo_path}")
logger.debug("NFO file not found: %s", nfo_path)
return result
try:
@@ -375,9 +375,9 @@ class NFOService:
)
except etree.XMLSyntaxError as e:
logger.error(f"Invalid XML in NFO file {nfo_path}: {e}")
logger.error("Invalid XML in NFO file %s: %s", nfo_path, e)
except Exception as e: # pylint: disable=broad-except
logger.error(f"Error parsing NFO file {nfo_path}: {e}")
logger.error("Error parsing NFO file %s: %s", nfo_path, e)
return result
@@ -480,7 +480,7 @@ class NFOService:
for result in results:
first_air_date = result.get("first_air_date", "")
if first_air_date.startswith(str(year)):
logger.debug(f"Found year match: {result['name']} ({first_air_date})")
logger.debug("Found year match: %s (%s)", result['name'], first_air_date)
return result
# Return first result (usually best match)
@@ -545,7 +545,7 @@ class NFOService:
skip_existing=True
)
logger.info(f"Media download results: {results}")
logger.info("Media download results: %s", results)
return results

8
src/core/services/series_manager_service.py
View File

@@ -136,7 +136,7 @@ class SeriesManagerService:
# If NFO exists, parse IDs and update database
if nfo_exists:
logger.debug(f"Parsing IDs from existing NFO for '{serie_name}'")
logger.debug("Parsing IDs from existing NFO for '%s'", serie_name)
ids = self.nfo_service.parse_nfo_ids(nfo_path)
if ids["tmdb_id"] or ids["tvdb_id"]:
@@ -203,14 +203,14 @@ class SeriesManagerService:
download_logo=self.download_logo,
download_fanart=self.download_fanart
)
logger.info(f"Successfully created NFO for '{serie_name}'")
logger.info("Successfully created NFO for '%s'", serie_name)
elif nfo_exists:
logger.debug(
f"NFO exists for '{serie_name}', skipping download"
)
except TMDBAPIError as e:
logger.error(f"TMDB API error processing '{serie_name}': {e}")
logger.error("TMDB API error processing '%s': %s", serie_name, e)
except Exception as e:
logger.error(
f"Unexpected error processing NFO for '{serie_name}': {e}",
@@ -246,7 +246,7 @@ class SeriesManagerService:
logger.info("No series found in database to process")
return
logger.info(f"Processing NFO for {len(anime_series_list)} series...")
logger.info("Processing NFO for %s series...", len(anime_series_list))
# Create tasks for concurrent processing
# Each task creates its own database session

20
src/core/services/tmdb_client.py
View File

@@ -107,7 +107,7 @@ class TMDBClient:
# Cache key for deduplication
cache_key = f"{endpoint}:{str(sorted(params.items()))}"
if cache_key in self._cache:
logger.debug(f"Cache hit for {endpoint}")
logger.debug("Cache hit for %s", endpoint)
return self._cache[cache_key]
delay = 1
@@ -121,7 +121,7 @@ class TMDBClient:
if self.session is None:
raise TMDBAPIError("Session is not available")
logger.debug(f"TMDB API request: {endpoint} (attempt {attempt + 1})")
logger.debug("TMDB API request: %s (attempt %s)", endpoint, attempt + 1)
async with self.session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=60)) as resp:
if resp.status == 401:
raise TMDBAPIError("Invalid TMDB API key")
@@ -130,7 +130,7 @@ class TMDBClient:
elif resp.status == 429:
# Rate limit - wait longer
retry_after = int(resp.headers.get('Retry-After', delay * 2))
logger.warning(f"Rate limited, waiting {retry_after}s")
logger.warning("Rate limited, waiting %ss", retry_after)
await asyncio.sleep(retry_after)
continue
@@ -142,26 +142,26 @@ class TMDBClient:
except asyncio.TimeoutError as e:
last_error = e
if attempt < max_retries - 1:
logger.warning(f"Request timeout (attempt {attempt + 1}), retrying in {delay}s")
logger.warning("Request timeout (attempt %s), retrying in %ss", attempt + 1, delay)
await asyncio.sleep(delay)
delay *= 2
else:
logger.error(f"Request timed out after {max_retries} attempts")
logger.error("Request timed out after %s attempts", max_retries)
except (aiohttp.ClientError, AttributeError) as e:
last_error = e
# If connector/session was closed, try to recreate it
if "Connector is closed" in str(e) or isinstance(e, AttributeError):
logger.warning(f"Session issue detected, recreating session: {e}")
logger.warning("Session issue detected, recreating session: %s", e)
self.session = None
await self._ensure_session()
if attempt < max_retries - 1:
logger.warning(f"Request failed (attempt {attempt + 1}): {e}, retrying in {delay}s")
logger.warning("Request failed (attempt %s): %s, retrying in %ss", attempt + 1, e, delay)
await asyncio.sleep(delay)
delay *= 2
else:
logger.error(f"Request failed after {max_retries} attempts: {e}")
logger.error("Request failed after %s attempts: %s", max_retries, e)
raise TMDBAPIError(f"Request failed after {max_retries} attempts: {last_error}")
@@ -275,7 +275,7 @@ class TMDBClient:
url = f"{self.image_base_url}/{size}{image_path}"
try:
logger.debug(f"Downloading image from {url}")
logger.debug("Downloading image from %s", url)
async with self.session.get(url, timeout=aiohttp.ClientTimeout(total=60)) as resp:
resp.raise_for_status()
@@ -286,7 +286,7 @@ class TMDBClient:
with open(local_path, "wb") as f:
f.write(await resp.read())
logger.info(f"Downloaded image to {local_path}")
logger.info("Downloaded image to %s", local_path)
except aiohttp.ClientError as e:
raise TMDBAPIError(f"Failed to download image: {e}")

33
src/core/utils/image_downloader.py
View File

@@ -125,7 +125,7 @@ class ImageDownloader:
# Check if file already exists
if skip_existing and local_path.exists():
if local_path.stat().st_size >= self.min_file_size:
logger.debug(f"Image already exists: {local_path}")
logger.debug("Image already exists: %s", local_path)
return True
# Ensure parent directory exists
@@ -137,15 +137,16 @@ class ImageDownloader:
for attempt in range(self.max_retries):
try:
logger.debug(
f"Downloading image from {url} "
f"(attempt {attempt + 1})"
"Downloading image from %s (attempt %d)",
url,
attempt + 1,
)
# Use persistent session
session = self._get_session()
async with session.get(url) as resp:
if resp.status == 404:
logger.warning(f"Image not found: {url}")
logger.warning("Image not found: %s", url)
return False
resp.raise_for_status()
@@ -168,21 +169,25 @@ class ImageDownloader:
local_path.unlink(missing_ok=True)
raise ImageDownloadError("Image validation failed")
logger.info(f"Downloaded image to {local_path}")
logger.info("Downloaded image to %s", local_path)
return True
except (aiohttp.ClientError, IOError, ImageDownloadError) as e:
last_error = e
if attempt < self.max_retries - 1:
logger.warning(
f"Download failed (attempt {attempt + 1}): {e}, "
f"retrying in {delay}s"
"Download failed (attempt %d): %s, retrying in %s",
attempt + 1,
e,
delay,
)
await asyncio.sleep(delay)
delay *= 2
else:
logger.error(
f"Download failed after {self.max_retries} attempts: {e}"
"Download failed after %d attempts: %s",
self.max_retries,
e,
)
raise ImageDownloadError(
@@ -211,7 +216,7 @@ class ImageDownloader:
try:
return await self.download_image(url, local_path, skip_existing)
except ImageDownloadError as e:
logger.warning(f"Failed to download poster: {e}")
logger.warning("Failed to download poster: %s", e)
return False
async def download_logo(
@@ -236,7 +241,7 @@ class ImageDownloader:
try:
return await self.download_image(url, local_path, skip_existing)
except ImageDownloadError as e:
logger.warning(f"Failed to download logo: {e}")
logger.warning("Failed to download logo: %s", e)
return False
async def download_fanart(
@@ -261,7 +266,7 @@ class ImageDownloader:
try:
return await self.download_image(url, local_path, skip_existing)
except ImageDownloadError as e:
logger.warning(f"Failed to download fanart: {e}")
logger.warning("Failed to download fanart: %s", e)
return False
def validate_image(self, image_path: Path) -> bool:
@@ -280,13 +285,13 @@ class ImageDownloader:
# Check file size
if image_path.stat().st_size < self.min_file_size:
logger.warning(f"Image file too small: {image_path}")
logger.warning("Image file too small: %s", image_path)
return False
return True
except Exception as e:
logger.warning(f"Image validation failed for {image_path}: {e}")
logger.warning("Image validation failed for %s: %s", image_path, e)
return False
async def download_all_media(
@@ -341,7 +346,7 @@ class ImageDownloader:
for (media_type, _), result in zip(tasks, task_results):
if isinstance(result, Exception):
logger.error(f"Error downloading {media_type}: {result}")
logger.error("Error downloading %s: %s", media_type, result)
results[media_type] = False
else:
results[media_type] = result

2
src/core/utils/nfo_generator.py
View File

@@ -209,5 +209,5 @@ def validate_nfo_xml(xml_string: str) -> bool:
etree.fromstring(xml_string.encode('utf-8'))
return True
except etree.XMLSyntaxError as e:
logger.error(f"Invalid NFO XML: {e}")
logger.error("Invalid NFO XML: %s", e)
return False

22
src/infrastructure/security/config_encryption.py
View File

@@ -36,10 +36,10 @@ class ConfigEncryption:
def _ensure_key_exists(self) -> None:
"""Ensure encryption key exists or create one."""
if not self.key_file.exists():
logger.info(f"Creating new encryption key at {self.key_file}")
logger.info("Creating new encryption key at %s", self.key_file)
self._generate_new_key()
else:
logger.info(f"Using existing encryption key from {self.key_file}")
logger.info("Using existing encryption key from %s", self.key_file)
def _generate_new_key(self) -> None:
"""Generate and store a new encryption key."""
@@ -56,7 +56,7 @@ class ConfigEncryption:
logger.info("Generated new encryption key")
except IOError as e:
logger.error(f"Failed to generate encryption key: {e}")
logger.error("Failed to generate encryption key: %s", e)
raise
def _load_key(self) -> bytes:
@@ -77,7 +77,7 @@ class ConfigEncryption:
key = self.key_file.read_bytes()
return key
except IOError as e:
logger.error(f"Failed to load encryption key: {e}")
logger.error("Failed to load encryption key: %s", e)
raise
def _get_cipher(self) -> Fernet:
@@ -117,7 +117,7 @@ class ConfigEncryption:
return encrypted_str
except Exception as e:
logger.error(f"Failed to encrypt value: {e}")
logger.error("Failed to encrypt value: %s", e)
raise
def decrypt_value(self, encrypted_value: str) -> str:
@@ -149,7 +149,7 @@ class ConfigEncryption:
return decrypted_str
except Exception as e:
logger.error(f"Failed to decrypt value: {e}")
logger.error("Failed to decrypt value: %s", e)
raise
def encrypt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
@@ -191,9 +191,9 @@ class ConfigEncryption:
'encrypted': True,
'value': self.encrypt_value(value)
}
logger.debug(f"Encrypted config field: {key}")
logger.debug("Encrypted config field: %s", key)
except Exception as e:
logger.warning(f"Failed to encrypt {key}: {e}")
logger.warning("Failed to encrypt %s: %s", key, e)
encrypted_config[key] = value
else:
encrypted_config[key] = value
@@ -222,9 +222,9 @@ class ConfigEncryption:
decrypted_config[key] = self.decrypt_value(
value['value']
)
logger.debug(f"Decrypted config field: {key}")
logger.debug("Decrypted config field: %s", key)
except Exception as e:
logger.error(f"Failed to decrypt {key}: {e}")
logger.error("Failed to decrypt %s: %s", key, e)
decrypted_config[key] = None
else:
decrypted_config[key] = value
@@ -248,7 +248,7 @@ class ConfigEncryption:
if self.key_file.exists():
backup_path = self.key_file.with_suffix('.key.bak')
self.key_file.rename(backup_path)
logger.info(f"Backed up old key to {backup_path}")
logger.info("Backed up old key to %s", backup_path)
# Generate new key
if new_key_file:

4
src/infrastructure/security/database_integrity.py
View File

@@ -276,13 +276,13 @@ class DatabaseIntegrityChecker:
removed += 1
self.session.commit()
logger.info(f"Removed {removed} orphaned records")
logger.info("Removed %s orphaned records", removed)
return removed
except Exception as e:
self.session.rollback()
logger.error(f"Error removing orphaned records: {e}")
logger.error("Error removing orphaned records: %s", e)
raise

27
src/infrastructure/security/file_integrity.py
View File

@@ -39,13 +39,15 @@ class FileIntegrityManager:
self.checksums = json.load(f)
count = len(self.checksums)
logger.info(
f"Loaded {count} checksums from {self.checksum_file}"
"Loaded %d checksums from %s",
count,
self.checksum_file,
)
except (json.JSONDecodeError, IOError) as e:
logger.error(f"Failed to load checksums: {e}")
logger.error("Failed to load checksums: %s", e)
self.checksums = {}
else:
logger.info(f"Checksum file does not exist: {self.checksum_file}")
logger.info("Checksum file does not exist: %s", self.checksum_file)
self.checksums = {}
def _save_checksums(self) -> None:
@@ -56,10 +58,12 @@ class FileIntegrityManager:
json.dump(self.checksums, f, indent=2)
count = len(self.checksums)
logger.debug(
f"Saved {count} checksums to {self.checksum_file}"
"Saved %d checksums to %s",
count,
self.checksum_file,
)
except IOError as e:
logger.error(f"Failed to save checksums: {e}")
logger.error("Failed to save checksums: %s", e)
def calculate_checksum(
self, file_path: Path, algorithm: str = "sha256"
@@ -94,12 +98,15 @@ class FileIntegrityManager:
checksum = hash_obj.hexdigest()
filename = file_path.name
logger.debug(
f"Calculated {algorithm} checksum for {filename}: {checksum}"
"Calculated %s checksum for %s: %s",
algorithm,
filename,
checksum,
)
return checksum
except IOError as e:
logger.error(f"Failed to read file {file_path}: {e}")
logger.error("Failed to read file %s: %s", file_path, e)
raise
def store_checksum(
@@ -126,7 +133,7 @@ class FileIntegrityManager:
self.checksums[key] = checksum
self._save_checksums()
logger.info(f"Stored checksum for {file_path.name}")
logger.info("Stored checksum for %s", file_path.name)
return checksum
def verify_checksum(
@@ -197,10 +204,10 @@ class FileIntegrityManager:
if key in self.checksums:
del self.checksums[key]
self._save_checksums()
logger.info(f"Removed checksum for {file_path.name}")
logger.info("Removed checksum for %s", file_path.name)
return True
else:
logger.debug(f"No checksum found to remove for {file_path.name}")
logger.debug("No checksum found to remove for %s", file_path.name)
return False
def has_checksum(self, file_path: Path) -> bool:

4
src/server/api/anime.py
View File

@@ -724,9 +724,9 @@ async def add_series(
if series_app and hasattr(series_app, 'loader'):
try:
year = series_app.loader.get_year(key)
logger.info(f"Fetched year for {key}: {year}")
logger.info("Fetched year for %s: %s", key, year)
except Exception as e:
logger.warning(f"Could not fetch year for {key}: {e}")
logger.warning("Could not fetch year for %s: %s", key, e)
# Create folder name with year if available
if year:

8
src/server/api/health.py
View File

@@ -91,7 +91,7 @@ async def check_database_health(db: AsyncSession) -> DatabaseHealth:
message="Database connection successful",
)
except Exception as e:
logger.error(f"Database health check failed: {e}")
logger.error("Database health check failed: %s", e)
return DatabaseHealth(
status="unhealthy",
connection_time_ms=0,
@@ -121,7 +121,7 @@ async def check_filesystem_health() -> Dict[str, Any]:
"message": "Filesystem check completed",
}
except Exception as e:
logger.error(f"Filesystem health check failed: {e}")
logger.error("Filesystem health check failed: %s", e)
return {
"status": "unhealthy",
"message": f"Filesystem check failed: {str(e)}",
@@ -164,7 +164,7 @@ def get_system_metrics() -> SystemMetrics:
uptime_seconds=uptime_seconds,
)
except Exception as e:
logger.error(f"System metrics collection failed: {e}")
logger.error("System metrics collection failed: %s", e)
raise HTTPException(
status_code=500, detail=f"Failed to collect system metrics: {str(e)}"
)
@@ -236,7 +236,7 @@ async def detailed_health_check(
startup_time=startup_time,
)
except Exception as e:
logger.error(f"Detailed health check failed: {e}")
logger.error("Detailed health check failed: %s", e)
raise HTTPException(status_code=500, detail="Health check failed")

8
src/server/api/nfo.py
View File

@@ -243,7 +243,7 @@ async def get_missing_nfo(
)
except Exception as e:
logger.error(f"Error getting missing NFOs: {e}", exc_info=True)
logger.exception("Error getting missing NFOs: %s", e)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to get missing NFOs: {str(e)}"
@@ -334,7 +334,7 @@ async def check_nfo(
except HTTPException:
raise
except Exception as e:
logger.error(f"Error checking NFO for {serie_id}: {e}", exc_info=True)
logger.exception("Error checking NFO for %s: %s", serie_id, e)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to check NFO: {str(e)}"
@@ -429,7 +429,7 @@ async def create_nfo(
except HTTPException:
raise
except TMDBAPIError as e:
logger.warning(f"TMDB API error creating NFO for {serie_id}: {e}")
logger.warning("TMDB API error creating NFO for %s: %s", serie_id, e)
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail=f"TMDB API error: {str(e)}"
@@ -524,7 +524,7 @@ async def update_nfo(
except HTTPException:
raise
except TMDBAPIError as e:
logger.warning(f"TMDB API error updating NFO for {serie_id}: {e}")
logger.warning("TMDB API error updating NFO for %s: %s", serie_id, e)
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail=f"TMDB API error: {str(e)}"

8
src/server/config/logging_config.py
View File

@@ -95,10 +95,10 @@ def setup_logging() -> Dict[str, logging.Logger]:
# Log initial setup
root_logger.info("=" * 80)
root_logger.info("FastAPI Server Logging Initialized")
root_logger.info(f"Log Level: {settings.log_level.upper()}")
root_logger.info(f"Server Log: {server_log_file.absolute()}")
root_logger.info(f"Error Log: {error_log_file.absolute()}")
root_logger.info(f"Access Log: {access_log_file.absolute()}")
root_logger.info("Log Level: %s", settings.log_level.upper())
root_logger.info("Server Log: %s", server_log_file.absolute())
root_logger.info("Error Log: %s", error_log_file.absolute())
root_logger.info("Access Log: %s", access_log_file.absolute())
root_logger.info("=" * 80)
return {

8
src/server/database/connection.py
View File

@@ -88,7 +88,7 @@ async def init_db() -> None:
try:
# Get database URL
db_url = _get_database_url()
logger.info(f"Initializing database: {db_url}")
logger.info("Initializing database: %s", db_url)
# Build engine kwargs based on database type
is_sqlite = "sqlite" in db_url
@@ -143,7 +143,7 @@ async def init_db() -> None:
logger.info("Database initialization complete")
except Exception as e:
logger.error(f"Failed to initialize database: {e}")
logger.error("Failed to initialize database: %s", e)
raise
@@ -171,7 +171,7 @@ async def close_db() -> None:
conn.commit()
logger.info("SQLite WAL checkpoint completed")
except Exception as e:
logger.warning(f"WAL checkpoint failed (non-critical): {e}")
logger.warning("WAL checkpoint failed (non-critical): %s", e)
if _engine:
logger.info("Closing async database engine...")
@@ -188,7 +188,7 @@ async def close_db() -> None:
logger.info("Database connections closed")
except Exception as e:
logger.error(f"Error closing database: {e}")
logger.error("Error closing database: %s", e)
def get_engine() -> AsyncEngine:

26
src/server/database/init.py
View File

@@ -98,7 +98,7 @@ async def initialize_database(
seed_data=True
)
if result["success"]:
logger.info(f"Database initialized: {result['schema_version']}")
logger.info("Database initialized: %s", result['schema_version'])
"""
if engine is None:
engine = get_engine()
@@ -117,7 +117,7 @@ async def initialize_database(
if create_schema:
tables = await create_database_schema(engine)
result["tables_created"] = tables
logger.info(f"Created {len(tables)} tables")
logger.info("Created %s tables", len(tables))
# Validate schema if requested
if validate_schema:
@@ -148,7 +148,7 @@ async def initialize_database(
return result
except Exception as e:
logger.error(f"Database initialization failed: {e}", exc_info=True)
logger.exception("Database initialization failed: %s", e)
raise RuntimeError(f"Failed to initialize database: {e}") from e
@@ -194,14 +194,14 @@ async def create_database_schema(
created_tables = [t for t in new_tables if t not in existing_tables]
if created_tables:
logger.info(f"Created tables: {', '.join(created_tables)}")
logger.info("Created tables: %s", ', '.join(created_tables))
else:
logger.info("All tables already exist")
return new_tables
except Exception as e:
logger.error(f"Failed to create schema: {e}", exc_info=True)
logger.exception("Failed to create schema: %s", e)
raise RuntimeError(f"Schema creation failed: {e}") from e
@@ -295,7 +295,7 @@ async def validate_database_schema(
return result
except Exception as e:
logger.error(f"Schema validation failed: {e}", exc_info=True)
logger.exception("Schema validation failed: %s", e)
return {
"valid": False,
"missing_tables": [],
@@ -342,7 +342,7 @@ async def get_schema_version(engine: Optional[AsyncEngine] = None) -> str:
return "unknown"
except Exception as e:
logger.error(f"Failed to get schema version: {e}")
logger.error("Failed to get schema version: %s", e)
return "error"
@@ -409,7 +409,7 @@ async def seed_initial_data(engine: Optional[AsyncEngine] = None) -> None:
logger.info("Data will be populated via normal application usage")
except Exception as e:
logger.error(f"Failed to seed initial data: {e}", exc_info=True)
logger.exception("Failed to seed initial data: %s", e)
raise
@@ -484,12 +484,12 @@ async def check_database_health(
f"(connectivity: {result['connectivity_ms']}ms)"
)
else:
logger.warning(f"Database health issues: {result['issues']}")
logger.warning("Database health issues: %s", result['issues'])
return result
except Exception as e:
logger.error(f"Database health check failed: {e}")
logger.error("Database health check failed: %s", e)
return {
"healthy": False,
"accessible": False,
@@ -547,13 +547,13 @@ async def create_database_backup(
backup_path = backup_dir / f"aniworld_{timestamp}.db"
try:
logger.info(f"Creating database backup: {backup_path}")
logger.info("Creating database backup: %s", backup_path)
shutil.copy2(db_path, backup_path)
logger.info(f"Backup created successfully: {backup_path}")
logger.info("Backup created successfully: %s", backup_path)
return backup_path
except Exception as e:
logger.error(f"Failed to create backup: {e}", exc_info=True)
logger.exception("Failed to create backup: %s", e)
raise RuntimeError(f"Backup creation failed: {e}") from e

22
src/server/database/service.py
View File

@@ -107,7 +107,7 @@ class AnimeSeriesService:
db.add(series)
await db.flush()
await db.refresh(series)
logger.info(f"Created anime series: {series.name} (key={series.key}, year={year})")
logger.info("Created anime series: %s (key=%s, year=%s)", series.name, series.key, year)
return series
@staticmethod
@@ -205,7 +205,7 @@ class AnimeSeriesService:
await db.flush()
await db.refresh(series)
logger.info(f"Updated anime series: {series.name} (id={series_id})")
logger.info("Updated anime series: %s (id=%s)", series.name, series_id)
return series
@staticmethod
@@ -226,7 +226,7 @@ class AnimeSeriesService:
)
deleted = result.rowcount > 0
if deleted:
logger.info(f"Deleted anime series with id={series_id}")
logger.info("Deleted anime series with id=%s", series_id)
return deleted
@staticmethod
@@ -701,7 +701,7 @@ class EpisodeService:
updated_count += 1
await db.flush()
logger.info(f"Bulk marked {updated_count} episodes as downloaded")
logger.info("Bulk marked %s episodes as downloaded", updated_count)
return updated_count
@@ -850,7 +850,7 @@ class DownloadQueueService:
await db.flush()
await db.refresh(item)
logger.debug(f"Set error on download queue item {item_id}")
logger.debug("Set error on download queue item %s", item_id)
return item
@staticmethod
@@ -869,7 +869,7 @@ class DownloadQueueService:
)
deleted = result.rowcount > 0
if deleted:
logger.info(f"Deleted download queue item with id={item_id}")
logger.info("Deleted download queue item with id=%s", item_id)
return deleted
@staticmethod
@@ -931,7 +931,7 @@ class DownloadQueueService:
)
count = result.rowcount
logger.info(f"Bulk deleted {count} download queue items")
logger.info("Bulk deleted %s download queue items", count)
return count
@@ -952,7 +952,7 @@ class DownloadQueueService:
"""
result = await db.execute(delete(DownloadQueueItem))
count = result.rowcount
logger.info(f"Cleared all {count} download queue items")
logger.info("Cleared all %s download queue items", count)
return count
@@ -1006,7 +1006,7 @@ class UserSessionService:
db.add(session)
await db.flush()
await db.refresh(session)
logger.info(f"Created user session: {session_id}")
logger.info("Created user session: %s", session_id)
return session
@staticmethod
@@ -1093,7 +1093,7 @@ class UserSessionService:
session.revoke()
await db.flush()
logger.info(f"Revoked user session: {session_id}")
logger.info("Revoked user session: %s", session_id)
return True
@staticmethod
@@ -1115,7 +1115,7 @@ class UserSessionService:
)
)
count = result.rowcount
logger.info(f"Cleaned up {count} expired sessions")
logger.info("Cleaned up %s expired sessions", count)
return count
@staticmethod

4
src/server/fastapi_app.py
View File

@@ -97,10 +97,10 @@ async def _check_incomplete_series_on_startup(background_loader) -> None:
logger.info("All series data is complete. No background loading needed.")
except Exception as e:
logger.error(f"Error checking incomplete series: {e}", exc_info=True)
logger.exception("Error checking incomplete series: %s", e)
except Exception as e:
logger.error(f"Failed to check incomplete series on startup: {e}", exc_info=True)
logger.exception("Failed to check incomplete series on startup: %s", e)
@asynccontextmanager

29
src/server/middleware/error_handler.py
View File

@@ -74,7 +74,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle authentication errors (401)."""
logger.warning(
f"Authentication error: {exc.message}",
"Authentication error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -94,7 +95,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle authorization errors (403)."""
logger.warning(
f"Authorization error: {exc.message}",
"Authorization error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -114,7 +116,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle validation errors (422)."""
logger.info(
f"Validation error: {exc.message}",
"Validation error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -134,7 +137,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle bad request errors (400)."""
logger.info(
f"Bad request error: {exc.message}",
"Bad request error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -154,7 +158,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle not found errors (404)."""
logger.info(
f"Not found error: {exc.message}",
"Not found error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -174,7 +179,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle conflict errors (409)."""
logger.info(
f"Conflict error: {exc.message}",
"Conflict error: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -194,7 +200,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle rate limit errors (429)."""
logger.warning(
f"Rate limit exceeded: {exc.message}",
"Rate limit exceeded: %s",
exc.message,
extra={"details": exc.details, "path": str(request.url.path)},
)
return JSONResponse(
@@ -214,7 +221,8 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle generic API exceptions."""
logger.error(
f"API error: {exc.message}",
"API error: %s",
exc.message,
extra={
"error_code": exc.error_code,
"details": exc.details,
@@ -238,12 +246,13 @@ def register_exception_handlers(app: FastAPI) -> None:
) -> JSONResponse:
"""Handle unexpected exceptions."""
logger.exception(
f"Unexpected error: {str(exc)}",
"Unexpected error: %s",
str(exc),
extra={"path": str(request.url.path)},
)
# Log full traceback for debugging
logger.debug(f"Traceback: {traceback.format_exc()}")
logger.debug("Traceback: %s", traceback.format_exc())
# Return generic error response for security
return JSONResponse(

12
src/server/middleware/security.py
View File

@@ -315,11 +315,11 @@ class RequestSanitizationMiddleware(BaseHTTPMiddleware):
None if malicious content detected, sanitized value otherwise
"""
if self.check_sql_injection and self._check_sql_injection(value):
logger.warning(f"Potential SQL injection detected: {value[:100]}")
logger.warning("Potential SQL injection detected: %s", value[:100])
return None
if self.check_xss and self._check_xss(value):
logger.warning(f"Potential XSS detected: {value[:100]}")
logger.warning("Potential XSS detected: %s", value[:100])
return None
return value
@@ -341,7 +341,7 @@ class RequestSanitizationMiddleware(BaseHTTPMiddleware):
content_type
and not any(ct in content_type for ct in self.allowed_content_types)
):
logger.warning(f"Unsupported content type: {content_type}")
logger.warning("Unsupported content type: %s", content_type)
return JSONResponse(
status_code=415,
content={"detail": "Unsupported Media Type"},
@@ -350,7 +350,7 @@ class RequestSanitizationMiddleware(BaseHTTPMiddleware):
# Check request size
content_length = request.headers.get("content-length")
if content_length and int(content_length) > self.max_request_size:
logger.warning(f"Request too large: {content_length} bytes")
logger.warning("Request too large: %s bytes", content_length)
return JSONResponse(
status_code=413,
content={"detail": "Request Entity Too Large"},
@@ -361,7 +361,7 @@ class RequestSanitizationMiddleware(BaseHTTPMiddleware):
if isinstance(value, str):
sanitized = self._sanitize_value(value)
if sanitized is None:
logger.warning(f"Malicious query parameter detected: {key}")
logger.warning("Malicious query parameter detected: %s", key)
return JSONResponse(
status_code=400,
content={"detail": "Malicious request detected"},
@@ -372,7 +372,7 @@ class RequestSanitizationMiddleware(BaseHTTPMiddleware):
if isinstance(value, str):
sanitized = self._sanitize_value(value)
if sanitized is None:
logger.warning(f"Malicious path parameter detected: {key}")
logger.warning("Malicious path parameter detected: %s", key)
return JSONResponse(
status_code=400,
content={"detail": "Malicious request detected"},

8
src/server/services/anime_service.py
View File

@@ -945,12 +945,12 @@ class AnimeService:
# Get the serie from in-memory cache
if not hasattr(self._app, 'list') or not hasattr(self._app.list, 'keyDict'):
logger.warning(f"Series list not available for episode sync: {series_key}")
logger.warning("Series list not available for episode sync: %s", series_key)
return 0
serie = self._app.list.keyDict.get(series_key)
if not serie:
logger.warning(f"Series not found in memory for episode sync: {series_key}")
logger.warning("Series not found in memory for episode sync: %s", series_key)
return 0
episodes_added = 0
@@ -959,7 +959,7 @@ class AnimeService:
# Get series from database
series_db = await AnimeSeriesService.get_by_key(db, series_key)
if not series_db:
logger.warning(f"Series not found in database: {series_key}")
logger.warning("Series not found in database: %s", series_key)
return 0
# Get existing episodes from database
@@ -1000,7 +1000,7 @@ class AnimeService:
try:
await self._broadcast_series_updated(series_key)
except Exception as e:
logger.warning(f"Failed to broadcast series update: {e}")
logger.warning("Failed to broadcast series update: %s", e)
return episodes_added

58
src/server/services/background_loader_service.py
View File

@@ -188,7 +188,7 @@ class BackgroundLoaderService:
"""
# Check if task already exists
if key in self.active_tasks:
logger.debug(f"Task for series {key} already exists, skipping")
logger.debug("Task for series %s already exists, skipping", key)
return
task = SeriesLoadingTask(
@@ -202,7 +202,7 @@ class BackgroundLoaderService:
self.active_tasks[key] = task
await self.task_queue.put(task)
logger.info(f"Added loading task for series: {key}")
logger.info("Added loading task for series: %s", key)
# Broadcast initial status
await self._broadcast_status(task)
@@ -277,7 +277,7 @@ class BackgroundLoaderService:
Args:
worker_id: Unique identifier for this worker instance
"""
logger.info(f"Background worker {worker_id} started processing tasks")
logger.info("Background worker %s started processing tasks", worker_id)
while not self._shutdown:
try:
@@ -301,14 +301,14 @@ class BackgroundLoaderService:
# No task available, continue loop
continue
except asyncio.CancelledError:
logger.info(f"Worker {worker_id} task cancelled")
logger.info("Worker %s task cancelled", worker_id)
break
except Exception as e:
logger.exception(f"Error in background worker {worker_id}: {e}")
logger.exception("Error in background worker %s: %s", worker_id, e)
# Continue processing other tasks
continue
logger.info(f"Background worker {worker_id} stopped")
logger.info("Background worker %s stopped", worker_id)
async def _load_series_data(self, task: SeriesLoadingTask) -> None:
"""Load all missing data for a series.
@@ -362,10 +362,10 @@ class BackgroundLoaderService:
# Broadcast completion
await self._broadcast_status(task)
logger.info(f"Successfully loaded all data for series: {task.key}")
logger.info("Successfully loaded all data for series: %s", task.key)
except Exception as e:
logger.exception(f"Error loading series data: {e}")
logger.exception("Error loading series data: %s", e)
task.status = LoadingStatus.FAILED
task.error = str(e)
task.completed_at = datetime.now(timezone.utc)
@@ -400,14 +400,14 @@ class BackgroundLoaderService:
# Check if directory exists
if series_dir.exists() and series_dir.is_dir():
logger.debug(f"Found series directory: {series_dir}")
logger.debug("Found series directory: %s", series_dir)
return series_dir
else:
logger.warning(f"Series directory not found: {series_dir}")
logger.warning("Series directory not found: %s", series_dir)
return None
except Exception as e:
logger.error(f"Error finding series directory for {task.key}: {e}")
logger.error("Error finding series directory for %s: %s", task.key, e)
return None
async def _scan_series_episodes(self, series_dir: Path, task: SeriesLoadingTask) -> Dict[str, List[str]]:
@@ -440,13 +440,13 @@ class BackgroundLoaderService:
if episodes:
episodes_by_season[season_name] = episodes
logger.debug(f"Found {len(episodes)} episodes in {season_name}")
logger.debug("Found %s episodes in %s", len(episodes), season_name)
logger.info(f"Scanned {len(episodes_by_season)} seasons for {task.key}")
logger.info("Scanned %s seasons for %s", len(episodes_by_season), task.key)
return episodes_by_season
except Exception as e:
logger.error(f"Error scanning episodes for {task.key}: {e}")
logger.error("Error scanning episodes for %s: %s", task.key, e)
return {}
async def _load_episodes(self, task: SeriesLoadingTask, db: Any) -> None:
@@ -466,7 +466,7 @@ class BackgroundLoaderService:
# Find series directory without full rescan
series_dir = await self._find_series_directory(task)
if not series_dir:
logger.error(f"Cannot load episodes - directory not found for {task.key}")
logger.error("Cannot load episodes - directory not found for %s", task.key)
task.progress["episodes"] = False
return
@@ -474,7 +474,7 @@ class BackgroundLoaderService:
episodes_by_season = await self._scan_series_episodes(series_dir, task)
if not episodes_by_season:
logger.warning(f"No episodes found for {task.key}")
logger.warning("No episodes found for %s", task.key)
task.progress["episodes"] = False
return
@@ -489,10 +489,10 @@ class BackgroundLoaderService:
series_db.loading_status = "loading_episodes"
await db.commit()
logger.info(f"Episodes loaded for series: {task.key} ({len(episodes_by_season)} seasons)")
logger.info("Episodes loaded for series: %s (%s seasons)", task.key, len(episodes_by_season))
except Exception as e:
logger.exception(f"Failed to load episodes for {task.key}: {e}")
logger.exception("Failed to load episodes for %s: %s", task.key, e)
raise
async def _load_nfo_and_images(self, task: SeriesLoadingTask, db: Any) -> bool:
@@ -521,7 +521,7 @@ class BackgroundLoaderService:
# Check if NFO already exists
if self.series_app.nfo_service.has_nfo(task.folder):
logger.info(f"NFO already exists for {task.key}, skipping creation")
logger.info("NFO already exists for %s, skipping creation", task.key)
# Update task progress
task.progress["nfo"] = True
@@ -536,19 +536,19 @@ class BackgroundLoaderService:
if not series_db.has_nfo:
series_db.has_nfo = True
series_db.nfo_created_at = datetime.now(timezone.utc)
logger.info(f"Updated database with existing NFO for {task.key}")
logger.info("Updated database with existing NFO for %s", task.key)
if not series_db.logo_loaded:
series_db.logo_loaded = True
if not series_db.images_loaded:
series_db.images_loaded = True
await db.commit()
logger.info(f"Existing NFO found and database updated for series: {task.key}")
logger.info("Existing NFO found and database updated for series: %s", task.key)
return False
# NFO doesn't exist, create it
await self._broadcast_status(task, "Generating NFO file...")
logger.info(f"Creating new NFO for {task.key}")
logger.info("Creating new NFO for %s", task.key)
# Use existing NFOService to create NFO with all images
# This reuses all existing TMDB API logic and image downloading
@@ -577,11 +577,11 @@ class BackgroundLoaderService:
series_db.loading_status = "loading_nfo"
await db.commit()
logger.info(f"NFO and images created and loaded for series: {task.key}")
logger.info("NFO and images created and loaded for series: %s", task.key)
return True
except Exception as e:
logger.exception(f"Failed to load NFO/images for {task.key}: {e}")
logger.exception("Failed to load NFO/images for %s: %s", task.key, e)
# Don't fail the entire task if NFO fails
task.progress["nfo"] = False
task.progress["logo"] = False
@@ -611,7 +611,7 @@ class BackgroundLoaderService:
# Scan for missing episodes using the targeted scan method
# This populates the episodeDict without triggering a full rescan
logger.info(f"Scanning missing episodes for {task.key}")
logger.info("Scanning missing episodes for %s", task.key)
missing_episodes = self.series_app.serie_scanner.scan_single_series(
key=task.key,
folder=task.folder
@@ -628,12 +628,12 @@ class BackgroundLoaderService:
# Notify anime_service to sync episodes to database
# Use sync_single_series_after_scan which gets data from serie_scanner.keyDict
if self.anime_service:
logger.debug(f"Calling anime_service.sync_single_series_after_scan for {task.key}")
logger.debug("Calling anime_service.sync_single_series_after_scan for %s", task.key)
await self.anime_service.sync_single_series_after_scan(task.key)
else:
logger.warning(f"anime_service not available, episodes will not be synced to DB for {task.key}")
logger.warning("anime_service not available, episodes will not be synced to DB for %s", task.key)
else:
logger.info(f"No missing episodes found for {task.key}")
logger.info("No missing episodes found for %s", task.key)
# Update series status in database
from src.server.database.service import AnimeSeriesService
@@ -648,7 +648,7 @@ class BackgroundLoaderService:
task.progress["episodes"] = True
except Exception as e:
logger.exception(f"Failed to scan missing episodes for {task.key}: {e}")
logger.exception("Failed to scan missing episodes for %s: %s", task.key, e)
task.progress["episodes"] = False
async def _broadcast_status(

26
src/server/services/cache_service.py
View File

@@ -170,14 +170,17 @@ class InMemoryCacheBackend(CacheBackend):
"""Get value from cache."""
async with self._lock:
if key not in self.cache:
logger.debug("Cache miss for key: %s", key)
return None
item = self.cache[key]
if self._is_expired(item):
logger.debug("Cache expired for key: %s", key)
del self.cache[key]
return None
logger.debug("Cache hit for key: %s", key)
return item["value"]
async def set(
@@ -196,6 +199,7 @@ class InMemoryCacheBackend(CacheBackend):
"expiry": expiry,
"created": datetime.utcnow(),
}
logger.debug("Cached key: %s (ttl=%s)", key, ttl)
return True
async def delete(self, key: str) -> bool:
@@ -203,7 +207,9 @@ class InMemoryCacheBackend(CacheBackend):
async with self._lock:
if key in self.cache:
del self.cache[key]
logger.debug("Deleted cache key: %s", key)
return True
logger.debug("Cache delete skipped; key not found: %s", key)
return False
async def exists(self, key: str) -> bool:
@@ -223,6 +229,7 @@ class InMemoryCacheBackend(CacheBackend):
"""Clear all cached values."""
async with self._lock:
self.cache.clear()
logger.debug("Cleared in-memory cache")
return True
async def get_many(self, keys: List[str]) -> Dict[str, Any]:
@@ -281,13 +288,14 @@ class RedisCacheBackend(CacheBackend):
import aioredis
self._redis = await aioredis.create_redis_pool(self.redis_url)
logger.debug("Connected to Redis at %s", self.redis_url)
except ImportError:
logger.error(
"aioredis not installed. Install with: pip install aioredis"
)
raise
except Exception as e:
logger.error(f"Failed to connect to Redis: {e}")
logger.error("Failed to connect to Redis: %s", e)
raise
return self._redis
@@ -308,7 +316,7 @@ class RedisCacheBackend(CacheBackend):
return pickle.loads(data)
except Exception as e:
logger.error(f"Redis get error: {e}")
logger.error("Redis get error: %s", e)
return None
async def set(
@@ -327,7 +335,7 @@ class RedisCacheBackend(CacheBackend):
return True
except Exception as e:
logger.error(f"Redis set error: {e}")
logger.error("Redis set error: %s", e)
return False
async def delete(self, key: str) -> bool:
@@ -338,7 +346,7 @@ class RedisCacheBackend(CacheBackend):
return result > 0
except Exception as e:
logger.error(f"Redis delete error: {e}")
logger.error("Redis delete error: %s", e)
return False
async def exists(self, key: str) -> bool:
@@ -348,7 +356,7 @@ class RedisCacheBackend(CacheBackend):
return await redis.exists(self._make_key(key))
except Exception as e:
logger.error(f"Redis exists error: {e}")
logger.error("Redis exists error: %s", e)
return False
async def clear(self) -> bool:
@@ -361,7 +369,7 @@ class RedisCacheBackend(CacheBackend):
return True
except Exception as e:
logger.error(f"Redis clear error: {e}")
logger.error("Redis clear error: %s", e)
return False
async def get_many(self, keys: List[str]) -> Dict[str, Any]:
@@ -379,7 +387,7 @@ class RedisCacheBackend(CacheBackend):
return result
except Exception as e:
logger.error(f"Redis get_many error: {e}")
logger.error("Redis get_many error: %s", e)
return {}
async def set_many(
@@ -392,7 +400,7 @@ class RedisCacheBackend(CacheBackend):
return True
except Exception as e:
logger.error(f"Redis set_many error: {e}")
logger.error("Redis set_many error: %s", e)
return False
async def delete_pattern(self, pattern: str) -> int:
@@ -409,7 +417,7 @@ class RedisCacheBackend(CacheBackend):
return 0
except Exception as e:
logger.error(f"Redis delete_pattern error: {e}")
logger.error("Redis delete_pattern error: %s", e)
return 0
async def close(self) -> None:

5
src/server/services/config_service.py
View File

@@ -8,6 +8,7 @@ This service handles:
"""
import json
import logging
import shutil
from datetime import datetime
from pathlib import Path
@@ -15,6 +16,8 @@ from typing import Dict, List, Optional
from src.server.models.config import AppConfig, ConfigUpdate, ValidationResult
logger = logging.getLogger(__name__)
class ConfigServiceError(Exception):
"""Base exception for configuration service errors."""
@@ -136,7 +139,7 @@ class ConfigService:
self.create_backup()
except ConfigBackupError as e:
# Log but don't fail save operation
print(f"Warning: Failed to create backup: {e}")
logger.warning("Failed to create backup: %s", e)
# Save configuration with version
data = config.model_dump()

2
src/server/services/initialization_service.py
View File

@@ -342,7 +342,7 @@ async def perform_nfo_scan_if_needed(progress_service=None):
if not settings.tmdb_api_key
else "Skipped - NFO features disabled"
)
logger.info(f"NFO scan skipped: {message}")
logger.info("NFO scan skipped: %s", message)
if progress_service:
await progress_service.complete_progress(

16
src/server/services/notification_service.py
View File

@@ -151,7 +151,7 @@ class EmailNotificationService:
start_tls=True,
)
logger.info(f"Email notification sent to {to_address}")
logger.info("Email notification sent to %s", to_address)
return True
except ImportError:
@@ -160,7 +160,7 @@ class EmailNotificationService:
)
return False
except Exception as e:
logger.error(f"Failed to send email notification: {e}")
logger.error("Failed to send email notification: %s", e)
return False
@@ -205,7 +205,7 @@ class WebhookNotificationService:
timeout=aiohttp.ClientTimeout(total=self.timeout),
) as response:
if response.status < 400:
logger.info(f"Webhook notification sent to {url}")
logger.info("Webhook notification sent to %s", url)
return True
else:
logger.warning(
@@ -213,9 +213,9 @@ class WebhookNotificationService:
)
except asyncio.TimeoutError:
logger.warning(f"Webhook timeout (attempt {attempt + 1}/{self.max_retries}): {url}")
logger.warning("Webhook timeout (attempt %s/%s): %s", attempt + 1, self.max_retries, url)
except Exception as e:
logger.error(f"Failed to send webhook (attempt {attempt + 1}/{self.max_retries}): {e}")
logger.error("Failed to send webhook (attempt %s/%s): %s", attempt + 1, self.max_retries, e)
if attempt < self.max_retries - 1:
await asyncio.sleep(2 ** attempt) # Exponential backoff
@@ -436,7 +436,7 @@ class NotificationService:
await self.in_app_service.add_notification(notification)
results["in_app"] = True
except Exception as e:
logger.error(f"Failed to send in-app notification: {e}")
logger.error("Failed to send in-app notification: %s", e)
results["in_app"] = False
# Send email notification
@@ -452,7 +452,7 @@ class NotificationService:
)
results["email"] = success
except Exception as e:
logger.error(f"Failed to send email notification: {e}")
logger.error("Failed to send email notification: %s", e)
results["email"] = False
# Send webhook notifications
@@ -476,7 +476,7 @@ class NotificationService:
success = await self.webhook_service.send_webhook(str(url), payload)
webhook_results.append(success)
except Exception as e:
logger.error(f"Failed to send webhook notification to {url}: {e}")
logger.error("Failed to send webhook notification to %s: %s", url, e)
webhook_results.append(False)
results["webhook"] = all(webhook_results) if webhook_results else False

34
src/server/utils/log_manager.py
View File

@@ -82,7 +82,7 @@ class LogManager:
log_path = self.log_dir / log_file
if not log_path.exists():
logger.warning(f"Log file not found: {log_file}")
logger.warning("Log file not found: %s", log_file)
return False
stat = log_path.stat()
@@ -99,10 +99,10 @@ class LogManager:
# Compress the rotated file
self._compress_log(rotated_path)
logger.info(f"Rotated log file: {log_file} -> {rotated_name}")
logger.info("Rotated log file: %s -> %s", log_file, rotated_name)
return True
except Exception as e:
logger.error(f"Failed to rotate log file {log_file}: {e}")
logger.error("Failed to rotate log file %s: %s", log_file, e)
return False
def _compress_log(self, log_path: Path) -> bool:
@@ -122,10 +122,10 @@ class LogManager:
shutil.copyfileobj(f_in, f_out)
log_path.unlink()
logger.debug(f"Compressed log file: {log_path.name}")
logger.debug("Compressed log file: %s", log_path.name)
return True
except Exception as e:
logger.error(f"Failed to compress log {log_path}: {e}")
logger.error("Failed to compress log %s: %s", log_path, e)
return False
def archive_old_logs(
@@ -160,10 +160,10 @@ class LogManager:
f"Failed to archive {log_file.filename}: {e}"
)
logger.info(f"Archived {archived_count} old log files")
logger.info("Archived %s old log files", archived_count)
return archived_count
except Exception as e:
logger.error(f"Failed to archive logs: {e}")
logger.error("Failed to archive logs: %s", e)
return 0
def search_logs(
@@ -209,7 +209,7 @@ class LogManager:
)
return results
except Exception as e:
logger.error(f"Failed to search logs: {e}")
logger.error("Failed to search logs: %s", e)
return {}
def export_logs(
@@ -243,7 +243,7 @@ class LogManager:
arcname=log_file.filename,
)
logger.info(f"Exported logs to: {tar_path}")
logger.info("Exported logs to: %s", tar_path)
return True
else:
# Concatenate all logs
@@ -253,10 +253,10 @@ class LogManager:
with open(log_file.path, "r") as in_f:
out_f.write(in_f.read())
logger.info(f"Exported logs to: {output_path}")
logger.info("Exported logs to: %s", output_path)
return True
except Exception as e:
logger.error(f"Failed to export logs: {e}")
logger.error("Failed to export logs: %s", e)
return False
def get_log_stats(self) -> Dict[str, Any]:
@@ -294,7 +294,7 @@ class LogManager:
"newest_file": log_files[0].filename,
}
except Exception as e:
logger.error(f"Failed to get log stats: {e}")
logger.error("Failed to get log stats: %s", e)
return {}
def cleanup_logs(
@@ -330,16 +330,16 @@ class LogManager:
log_file.path.unlink()
total_size -= log_file.size_bytes
deleted_count += 1
logger.debug(f"Deleted log file: {log_file.filename}")
logger.debug("Deleted log file: %s", log_file.filename)
except Exception as e:
logger.warning(
f"Failed to delete {log_file.filename}: {e}"
)
logger.info(f"Cleaned up {deleted_count} log files")
logger.info("Cleaned up %s log files", deleted_count)
return deleted_count
except Exception as e:
logger.error(f"Failed to cleanup logs: {e}")
logger.error("Failed to cleanup logs: %s", e)
return 0
def set_log_level(self, logger_name: str, level: str) -> bool:
@@ -357,10 +357,10 @@ class LogManager:
target_logger = logging.getLogger(logger_name)
target_logger.setLevel(log_level)
logger.info(f"Set {logger_name} log level to {level}")
logger.info("Set %s log level to %s", logger_name, level)
return True
except Exception as e:
logger.error(f"Failed to set log level: {e}")
logger.error("Failed to set log level: %s", e)
return False

4
src/server/utils/logging.py
View File

@@ -416,9 +416,9 @@ def cleanup_old_logs(log_dir: Union[str, Path],
try:
if log_file.stat().st_mtime < cutoff_time:
log_file.unlink()
logger.info(f"Deleted old log file: {log_file}")
logger.info("Deleted old log file: %s", log_file)
except Exception as e:
logger.error(f"Failed to delete log file {log_file}: {e}")
logger.error("Failed to delete log file %s: %s", log_file, e)
# Initialize default logging configuration

2
src/server/utils/metrics.py
View File

@@ -161,7 +161,7 @@ class MetricsCollector:
Duration in seconds.
"""
if timer_name not in self._timers:
logger.warning(f"Timer {timer_name} not started")
logger.warning("Timer %s not started", timer_name)
return 0.0
duration = time.time() - self._timers[timer_name]

34
src/server/utils/system.py
View File

@@ -60,7 +60,7 @@ class SystemUtilities:
path=path,
)
except Exception as e:
logger.error(f"Failed to get disk usage for {path}: {e}")
logger.error("Failed to get disk usage for %s: %s", path, e)
return None
@staticmethod
@@ -93,7 +93,7 @@ class SystemUtilities:
return disk_infos
except Exception as e:
logger.error(f"Failed to get all disk usage: {e}")
logger.error("Failed to get all disk usage: %s", e)
return []
@staticmethod
@@ -115,7 +115,7 @@ class SystemUtilities:
path = Path(directory)
if not path.exists():
logger.warning(f"Directory not found: {directory}")
logger.warning("Directory not found: %s", directory)
return 0
deleted_count = 0
@@ -130,16 +130,16 @@ class SystemUtilities:
try:
file_path.unlink()
deleted_count += 1
logger.debug(f"Deleted file: {file_path}")
logger.debug("Deleted file: %s", file_path)
except Exception as e:
logger.warning(
f"Failed to delete {file_path}: {e}"
)
logger.info(f"Cleaned up {deleted_count} files from {directory}")
logger.info("Cleaned up %s files from %s", deleted_count, directory)
return deleted_count
except Exception as e:
logger.error(f"Failed to cleanup directory {directory}: {e}")
logger.error("Failed to cleanup directory %s: %s", directory, e)
return 0
@staticmethod
@@ -171,12 +171,12 @@ class SystemUtilities:
f"Deleted empty directory: {dir_path}"
)
except Exception as e:
logger.debug(f"Cannot delete {dir_path}: {e}")
logger.debug("Cannot delete %s: %s", dir_path, e)
logger.info(f"Cleaned up {deleted_count} empty directories")
logger.info("Cleaned up %s empty directories", deleted_count)
return deleted_count
except Exception as e:
logger.error(f"Failed to cleanup empty directories: {e}")
logger.error("Failed to cleanup empty directories: %s", e)
return 0
@staticmethod
@@ -201,7 +201,7 @@ class SystemUtilities:
return total_size
except Exception as e:
logger.error(f"Failed to get directory size for {directory}: {e}")
logger.error("Failed to get directory size for %s: %s", directory, e)
return 0
@staticmethod
@@ -232,7 +232,7 @@ class SystemUtilities:
),
)
except Exception as e:
logger.error(f"Failed to get process info for {pid}: {e}")
logger.error("Failed to get process info for %s: %s", pid, e)
return None
@staticmethod
@@ -260,7 +260,7 @@ class SystemUtilities:
return processes
except Exception as e:
logger.error(f"Failed to get all processes: {e}")
logger.error("Failed to get all processes: %s", e)
return []
@staticmethod
@@ -285,7 +285,7 @@ class SystemUtilities:
"python_version": platform.python_version(),
}
except Exception as e:
logger.error(f"Failed to get system info: {e}")
logger.error("Failed to get system info: %s", e)
return {}
@staticmethod
@@ -308,7 +308,7 @@ class SystemUtilities:
"dropped_out": net_io.dropout,
}
except Exception as e:
logger.error(f"Failed to get network info: {e}")
logger.error("Failed to get network info: %s", e)
return {}
@staticmethod
@@ -330,7 +330,7 @@ class SystemUtilities:
dest_path = Path(dest)
if not src_path.exists():
logger.error(f"Source file not found: {src}")
logger.error("Source file not found: %s", src)
return False
# Create temporary file
@@ -342,10 +342,10 @@ class SystemUtilities:
# Atomic rename
temp_path.replace(dest_path)
logger.debug(f"Atomically copied {src} to {dest}")
logger.debug("Atomically copied %s to %s", src, dest)
return True
except Exception as e:
logger.error(f"Failed to copy file {src} to {dest}: {e}")
logger.error("Failed to copy file %s to %s: %s", src, dest, e)
return False