"""Configuration management for Video Library Manager.""" from dataclasses import dataclass, field from pathlib import Path from typing import Optional import yaml @dataclass class Config: """Configuration for Video Library Manager.""" library_root: Path video_extensions: list[str] = field(default_factory=lambda: [ ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v" ]) movie_template: str = "movie/{title} ({year})/" series_template: str = "series/{title}/Season {season:02d}/" movie_filename_template: str = "{title} ({year}){ext}" series_filename_template: str = "S{season:02d}E{episode:02d}{ext}" log_level: str = "INFO" quarantine_dir: str = ".quarantine" categories: dict[str, list[str]] = field(default_factory=lambda: { "movie": ["movie", "movies"], "series": ["series", "tv", "shows"], "anime": ["anime"] }) # Enrichment settings enrichment_enabled: bool = True enrichment_incremental: bool = True enrichment_refresh_mode: str = "manual" enrichment_providers: list[str] = field(default_factory=lambda: ["tmdb", "douban"]) enrichment_cache_db: Path = field(default_factory=lambda: Path.home() / ".vlm" / "enrichment_cache.db") enrichment_max_concurrency: int = 6 enrichment_min_match_score: float = 0.75 translation_mode: str = "bidirectional" translation_fallback_machine: bool = True tmdb_api_key: Optional[str] = None douban_api_key: Optional[str] = None douban_api_endpoint: Optional[str] = None openai_api_key: Optional[str] = None reputation_min_votes: int = 50 reputation_low_score_threshold: float = 6.0 reputation_policy: str = "flag_for_review" naming_title_format: str = "{title_zh} {title_en}" def load_config(path: Path) -> Config: """Load configuration from YAML file.""" if not path.exists(): raise FileNotFoundError(f"Configuration file not found: {path}") try: with open(path, "r", encoding="utf-8") as f: data = yaml.safe_load(f) except yaml.YAMLError as e: raise yaml.YAMLError(f"Invalid YAML syntax in configuration file: {e}") if data is None: data = {} library_root_str = data.get("library_root") if not library_root_str: raise ValueError("Configuration must specify 'library_root'") library_root = Path(library_root_str).expanduser() video_extensions = data.get("video_extensions", [ ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v" ]) templates = data.get("templates", {}) movie_template = templates.get("movie_dir", "movie/{title} ({year})/") series_template = templates.get("series_dir", "series/{title}/Season {season:02d}/") movie_filename_template = templates.get("movie_filename", "{title} ({year}){ext}") series_filename_template = templates.get("series_filename", "S{season:02d}E{episode:02d}{ext}") quarantine_dir = data.get("quarantine_dir", ".quarantine") log_level = data.get("log_level", "INFO") categories = data.get("categories", { "movie": ["movie", "movies"], "series": ["series", "tv", "shows"], "anime": ["anime"] }) enrichment = data.get("enrichment", {}) translation = enrichment.get("translation", {}) api_keys = enrichment.get("api_keys", {}) reputation = enrichment.get("reputation", {}) naming = enrichment.get("naming", {}) return Config( library_root=library_root, video_extensions=video_extensions, movie_template=movie_template, series_template=series_template, movie_filename_template=movie_filename_template, series_filename_template=series_filename_template, log_level=log_level, quarantine_dir=quarantine_dir, categories=categories, enrichment_enabled=enrichment.get("enabled", True), enrichment_incremental=enrichment.get("incremental", True), enrichment_refresh_mode=enrichment.get("refresh_mode", "manual"), enrichment_providers=enrichment.get("providers", ["tmdb", "douban"]), enrichment_cache_db=Path( enrichment.get("cache_db", str(Path.home() / ".vlm" / "enrichment_cache.db")) ).expanduser(), enrichment_max_concurrency=enrichment.get("max_concurrency", 6), enrichment_min_match_score=enrichment.get("min_match_score", 0.75), translation_mode=translation.get("mode", "bidirectional"), translation_fallback_machine=translation.get("fallback_machine", True), tmdb_api_key=api_keys.get("tmdb"), douban_api_key=api_keys.get("douban"), douban_api_endpoint=enrichment.get("douban_endpoint"), openai_api_key=api_keys.get("openai"), reputation_min_votes=reputation.get("min_votes", 50), reputation_low_score_threshold=reputation.get("low_score_threshold", 6.0), reputation_policy=reputation.get("policy", "flag_for_review"), naming_title_format=naming.get("title_format", "{title_zh} {title_en}"), ) def create_default_config(path: Path) -> Config: """Create a default configuration file and return the Config object.""" default_config = Config( library_root=Path.home() / "Videos", video_extensions=[".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v"], ) yaml_content = { "library_root": str(default_config.library_root), "video_extensions": default_config.video_extensions, "templates": { "movie_dir": default_config.movie_template, "series_dir": default_config.series_template, "movie_filename": default_config.movie_filename_template, "series_filename": default_config.series_filename_template, }, "quarantine_dir": default_config.quarantine_dir, "log_level": default_config.log_level, "categories": default_config.categories, "enrichment": { "enabled": default_config.enrichment_enabled, "incremental": default_config.enrichment_incremental, "refresh_mode": default_config.enrichment_refresh_mode, "providers": default_config.enrichment_providers, "cache_db": str(default_config.enrichment_cache_db), "max_concurrency": default_config.enrichment_max_concurrency, "min_match_score": default_config.enrichment_min_match_score, "translation": { "mode": default_config.translation_mode, "fallback_machine": default_config.translation_fallback_machine, }, "api_keys": { "tmdb": default_config.tmdb_api_key, "douban": default_config.douban_api_key, "openai": default_config.openai_api_key, }, "douban_endpoint": default_config.douban_api_endpoint, "reputation": { "min_votes": default_config.reputation_min_votes, "low_score_threshold": default_config.reputation_low_score_threshold, "policy": default_config.reputation_policy, }, "naming": { "title_format": default_config.naming_title_format, }, }, } path.parent.mkdir(parents=True, exist_ok=True) with open(path, "w", encoding="utf-8") as f: yaml.dump(yaml_content, f, default_flow_style=False, sort_keys=False) return default_config def validate_config(config: Config) -> list[str]: """Validate configuration and return list of error messages.""" errors = [] if not isinstance(config.library_root, Path): errors.append("library_root must be a Path object") elif not str(config.library_root) or str(config.library_root) == ".": errors.append("library_root cannot be empty") if not config.video_extensions: errors.append("video_extensions cannot be empty") elif not isinstance(config.video_extensions, list): errors.append("video_extensions must be a list") else: for ext in config.video_extensions: if not isinstance(ext, str): errors.append(f"video_extensions must contain strings, found: {type(ext)}") break if not ext.startswith("."): errors.append(f"video extension must start with '.': {ext}") if not config.movie_template: errors.append("movie_template cannot be empty") elif not isinstance(config.movie_template, str): errors.append("movie_template must be a string") if not config.series_template: errors.append("series_template cannot be empty") elif not isinstance(config.series_template, str): errors.append("series_template must be a string") if not config.movie_filename_template: errors.append("movie_filename_template cannot be empty") elif not isinstance(config.movie_filename_template, str): errors.append("movie_filename_template must be a string") if not config.series_filename_template: errors.append("series_filename_template cannot be empty") elif not isinstance(config.series_filename_template, str): errors.append("series_filename_template must be a string") valid_log_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] if not config.log_level: errors.append("log_level cannot be empty") elif not isinstance(config.log_level, str): errors.append("log_level must be a string") elif config.log_level.upper() not in valid_log_levels: errors.append(f"log_level must be one of {valid_log_levels}, got: {config.log_level}") if not config.quarantine_dir: errors.append("quarantine_dir cannot be empty") elif not isinstance(config.quarantine_dir, str): errors.append("quarantine_dir must be a string") elif config.quarantine_dir.startswith("/") or config.quarantine_dir.startswith("\\"): errors.append("quarantine_dir must be relative to category root, not absolute") if not config.categories: errors.append("categories cannot be empty") elif not isinstance(config.categories, dict): errors.append("categories must be a dictionary") else: required_categories = {"movie", "series", "anime"} missing = required_categories - set(config.categories.keys()) if missing: errors.append(f"categories must include keys: {sorted(missing)}") seen_dirs = {} for category, dir_list in config.categories.items(): if not isinstance(dir_list, list): errors.append(f"categories['{category}'] must be a list") continue if not dir_list: errors.append(f"categories['{category}'] cannot be empty") continue for dir_name in dir_list: if not isinstance(dir_name, str): errors.append(f"categories['{category}'] must contain strings") break if not dir_name.strip(): errors.append(f"categories['{category}'] contains empty directory name") break dir_lower = dir_name.lower() if dir_lower in seen_dirs: errors.append( f"Duplicate directory name '{dir_name}' in categories " f"'{category}' and '{seen_dirs[dir_lower]}'" ) else: seen_dirs[dir_lower] = category if not isinstance(config.enrichment_cache_db, Path): errors.append("enrichment_cache_db must be a Path object") if not isinstance(config.enrichment_providers, list) or not config.enrichment_providers: errors.append("enrichment_providers must be a non-empty list") if config.enrichment_max_concurrency < 1: errors.append("enrichment_max_concurrency must be >= 1") if not (0.0 <= config.enrichment_min_match_score <= 1.0): errors.append("enrichment_min_match_score must be between 0.0 and 1.0") if config.enrichment_refresh_mode not in {"manual"}: errors.append("enrichment_refresh_mode must be 'manual'") if config.reputation_min_votes < 0: errors.append("reputation_min_votes must be >= 0") if not (0.0 <= config.reputation_low_score_threshold <= 10.0): errors.append("reputation_low_score_threshold must be between 0.0 and 10.0") return errors