def get_tvdb_ids_from_url(self, tvdb_url, language): show_ids = [] movie_ids = [] tvdb_url = tvdb_url.strip() if tvdb_url.startswith((self.list_url, self.alt_list_url)): try: items = self.send_request(tvdb_url, language).xpath("//div[@class='col-xs-12 col-sm-12 col-md-8 col-lg-8 col-md-pull-4']/div[@class='row']") for item in items: title = item.xpath(".//div[@class='col-xs-12 col-sm-9 mt-2']//a/text()")[0] item_url = item.xpath(".//div[@class='col-xs-12 col-sm-9 mt-2']//a/@href")[0] if item_url.startswith("/series/"): try: show_ids.append(self.get_series(language, tvdb_url="{}{}".format(self.site_url, item_url)).id) except Failed as e: logger.error("{} for series {}".format(e, title)) elif item_url.startswith("/movies/"): try: tmdb_id = self.get_movie(language, tvdb_url="{}{}".format(self.site_url, item_url)).tmdb_id if tmdb_id: movie_ids.append(tmdb_id) else: raise Failed("TVDb Error: TMDb ID not found from TVDb URL: {}".format(tvdb_url)) except Failed as e: logger.error("{} for series {}".format(e, title)) else: logger.error("TVDb Error: Skipping Movie: {}".format(title)) if len(show_ids) > 0 or len(movie_ids) > 0: return movie_ids, show_ids raise Failed("TVDb Error: No TVDb IDs found at {}".format(tvdb_url)) except requests.exceptions.MissingSchema as e: util.print_stacktrace() raise Failed("TVDb Error: URL Lookup Failed for {}".format(tvdb_url)) else: raise Failed("TVDb Error: {} must begin with {}".format(tvdb_url, self.list_url))
def __init__(self, params): self.url = params["url"] self.token = params["token"] self.version = params["version"] self.base_url = f"{self.url}/api{'/v3' if self.version == 'v3' else ''}/" try: result = requests.get(f"{self.base_url}system/status", params={ "apikey": f"{self.token}" }).json() except Exception: util.print_stacktrace() raise Failed( f"Radarr Error: Could not connect to Radarr at {self.url}") if "error" in result and result["error"] == "Unauthorized": raise Failed("Radarr Error: Invalid API Key") if "version" not in result: raise Failed("Radarr Error: Unexpected Response Check URL") self.add = params["add"] self.root_folder_path = params["root_folder_path"] self.monitor = params["monitor"] self.availability = params["availability"] self.quality_profile_id = self.get_profile_id( params["quality_profile"]) self.tag = params["tag"] self.tags = self.get_tags() self.search = params["search"]
def map_guids(self, library): movie_map = {} show_map = {} length = 0 count = 0 logger.info("Mapping {} Library: {}".format("Movie" if library.is_movie else "Show", library.name)) items = library.Plex.all() for i, item in enumerate(items, 1): length = util.print_return(length, "Processing: {}/{} {}".format(i, len(items), item.title)) try: id_type, main_id = self.get_id(item, library, length) except BadRequest: util.print_stacktrace() util.print_end(length, "{} {:<46} | {} for {}".format("Cache | ! |" if self.Cache else "Mapping Error:", item.guid, error_message, item.title)) continue if isinstance(main_id, list): if id_type == "movie": for m in main_id: movie_map[m] = item.ratingKey elif id_type == "show": for m in main_id: show_map[m] = item.ratingKey else: if id_type == "movie": movie_map[main_id] = item.ratingKey elif id_type == "show": show_map[main_id] = item.ratingKey util.print_end(length, "Processed {} {}".format(len(items), "Movies" if library.is_movie else "Shows")) return movie_map, show_map
def __init__(self, tmdb, params): self.url_params = {"apikey": "{}".format(params["token"])} self.base_url = "{}/api{}".format(params["url"], "/v3/" if params["version"] == "v3" else "/") try: result = requests.get("{}system/status".format(self.base_url), params=self.url_params).json() except Exception as e: util.print_stacktrace() raise Failed("Radarr Error: Could not connect to Radarr at {}".format(params["url"])) if "error" in result and result["error"] == "Unauthorized": raise Failed("Radarr Error: Invalid API Key") if "version" not in result: raise Failed("Radarr Error: Unexpected Response Check URL") self.quality_profile_id = None profiles = "" for profile in self.send_get("{}{}".format(self.base_url, "qualityProfile" if params["version"] == "v3" else "profile")): if len(profiles) > 0: profiles += ", " profiles += profile["name"] if profile["name"] == params["quality_profile"]: self.quality_profile_id = profile["id"] if not self.quality_profile_id: raise Failed("Radarr Error: quality_profile: {} does not exist in radarr. Profiles available: {}".format(params["quality_profile"], profiles)) self.tmdb = tmdb self.url = params["url"] self.version = params["version"] self.token = params["token"] self.root_folder_path = params["root_folder_path"] self.add = params["add"] self.search = params["search"] self.tag = params["tag"]
def __init__(self, params): try: response = requests.get(f"{params['url']}/api/v2?apikey={params['apikey']}&cmd=get_library_names").json() except Exception: util.print_stacktrace() raise Failed("Tautulli Error: Invalid url") if response["response"]["result"] != "success": raise Failed(f"Tautulli Error: {response['response']['message']}") self.url = params["url"] self.apikey = params["apikey"]
def start(config_path): try: util.seperator("Starting Daily Run") config = Config(default_dir, config_path) config.update_libraries() except Exception as e: util.print_stacktrace() logger.critical(e) logger.info("") util.seperator("Finished Daily Run")
def __init__(self, params): try: response = requests.get( "{}/api/v2?apikey={}&cmd=get_library_names".format( params["url"], params["apikey"])).json() except Exception as e: util.print_stacktrace() raise Failed("Tautulli Error: Invalid url") if response["response"]["result"] != "success": raise Failed("Tautulli Error: {}".format( response["response"]["message"])) self.url = params["url"] self.apikey = params["apikey"]
def start(config_path, test, daily, collections): if daily: type = "Daily " elif test: type = "Test " elif collections: type = "Collections " else: type = "" util.seperator("Starting {}Run".format(type)) try: config = Config(default_dir, config_path) config.update_libraries(test, collections) except Exception as e: util.print_stacktrace() logger.critical(e) logger.info("") util.seperator("Finished {}Run".format(type))
def __init__(self, config, library, params): self.config = config self.library = library self.url = params["url"] self.apikey = params["apikey"] try: response = self._request( f"{self.url}/api/v2?apikey={self.apikey}&cmd=get_library_names" ) except Exception: util.print_stacktrace() raise Failed("Tautulli Error: Invalid url") if response["response"]["result"] != "success": raise Failed(f"Tautulli Error: {response['response']['message']}")
def edit_item(self, item, name, item_type, edits, advanced=False): if len(edits) > 0: logger.debug(f"Details Update: {edits}") try: if advanced: item.editAdvanced(**edits) else: item.edit(**edits) item.reload() if advanced and "languageOverride" in edits: self.refresh_item(item.ratingKey) logger.info(f"{item_type}: {name}{' Advanced' if advanced else ''} Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"{item_type}: {name}{' Advanced' if advanced else ''} Details Update Failed")
def start(config_path, is_test, daily, collections_to_run, libraries_to_run, resume_from): if daily: start_type = "Daily " elif is_test: start_type = "Test " elif collections_to_run: start_type = "Collections " elif libraries_to_run: start_type = "Libraries " else: start_type = "" start_time = datetime.now() util.separator(f"Starting {start_type}Run") try: config = Config(default_dir, config_path, libraries_to_run) config.update_libraries(is_test, collections_to_run, resume_from) except Exception as e: util.print_stacktrace() logger.critical(e) logger.info("") util.separator(f"Finished {start_type}Run\nRun Time: {str(datetime.now() - start_time).split('.')[0]}")
def _ids_from_url(self, tvdb_url): ids = [] tvdb_url = tvdb_url.strip() if self.config.trace_mode: logger.debug(f"URL: {tvdb_url}") if tvdb_url.startswith((urls["list"], urls["alt_list"])): try: response = self.config.get_html(tvdb_url, headers=util.header( self.tvdb_language)) items = response.xpath( "//div[@class='col-xs-12 col-sm-12 col-md-8 col-lg-8 col-md-pull-4']/div[@class='row']" ) for item in items: title = item.xpath( ".//div[@class='col-xs-12 col-sm-9 mt-2']//a/text()" )[0] item_url = item.xpath( ".//div[@class='col-xs-12 col-sm-9 mt-2']//a/@href")[0] if item_url.startswith("/series/"): try: ids.append( (self.get_series(f"{base_url}{item_url}").id, "tvdb")) except Failed as e: logger.error(f"{e} for series {title}") elif item_url.startswith("/movies/"): try: movie = self.get_movie(f"{base_url}{item_url}") if movie.tmdb_id: ids.append((movie.tmdb_id, "tmdb")) elif movie.imdb_id: ids.append((movie.imdb_id, "imdb")) except Failed as e: logger.error(e) else: logger.error(f"TVDb Error: Skipping Movie: {title}") time.sleep(2) if len(ids) > 0: return ids raise Failed(f"TVDb Error: No TVDb IDs found at {tvdb_url}") except requests.exceptions.MissingSchema: util.print_stacktrace() raise Failed(f"TVDb Error: URL Lookup Failed for {tvdb_url}") else: raise Failed( f"TVDb Error: {tvdb_url} must begin with {urls['list']}")
def tautulli_tests(config): if config.libraries[0].Tautulli: util.separator("Tautulli Tests") try: config.libraries[0].Tautulli.get_section_id( config.libraries[0].name) logger.info("Success | Get Section ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get Section ID: {e}") try: config.libraries[0].Tautulli.get_popular(config.libraries[0], status_message=False) logger.info("Success | Get Popular") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get Popular: {e}") try: config.libraries[0].Tautulli.get_top(config.libraries[0], status_message=False) logger.info("Success | Get Top") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get Top: {e}") else: util.separator("Tautulli Not Configured")
def __init__(self, tvdb, params, language): self.url_params = {"apikey": f"{params['token']}"} self.base_url = f"{params['url']}/api{'/v3/' if params['version'] == 'v3' else '/'}" try: result = requests.get(f"{self.base_url}system/status", params=self.url_params).json() except Exception: util.print_stacktrace() raise Failed( f"Sonarr Error: Could not connect to Sonarr at {params['url']}" ) if "error" in result and result["error"] == "Unauthorized": raise Failed("Sonarr Error: Invalid API Key") if "version" not in result: raise Failed("Sonarr Error: Unexpected Response Check URL") self.quality_profile_id = None profiles = "" for profile in self.send_get( f"{self.base_url}{'qualityProfile' if params['version'] == 'v3' else 'profile'}" ): if len(profiles) > 0: profiles += ", " profiles += profile["name"] if profile["name"] == params["quality_profile"]: self.quality_profile_id = profile["id"] if not self.quality_profile_id: raise Failed( f"Sonarr Error: quality_profile: {params['quality_profile']} does not exist in sonarr. Profiles available: {profiles}" ) self.tvdb = tvdb self.language = language self.url = params["url"] self.version = params["version"] self.token = params["token"] self.root_folder_path = params["root_folder_path"] self.add = params["add"] self.search = params["search"] self.season_folder = params["season_folder"] self.tag = params["tag"]
def mal_tests(config): if config.MyAnimeList: util.separator("MyAnimeList Tests") mal_list_tests = [("mal_all", 10), ("mal_airing", 10), ("mal_upcoming", 10), ("mal_tv", 10), ("mal_movie", 10), ("mal_ova", 10), ("mal_special", 10), ("mal_popular", 10), ("mal_favorite", 10), ("mal_suggested", 10), ("mal_userlist", { "limit": 10, "username": "******", "status": "completed", "sort_by": "list_score" }), ("mal_season", { "limit": 10, "season": "fall", "year": 2020, "sort_by": "anime_score" })] for mal_list_test in mal_list_tests: try: config.MyAnimeList.get_items(mal_list_test[0], mal_list_test[1], status_message=False) logger.info( f"Success | Get Anime using {util.pretty_names[mal_list_test[0]]}" ) except Failed as e: util.print_stacktrace() logger.error( f"Failure | Get Anime using {util.pretty_names[mal_list_test[0]]}: {e}" ) else: util.separator("MyAnimeList Not Configured")
def __init__(self, params, language): self.url = params["url"] self.token = params["token"] self.version = params["version"] self.base_url = f"{self.url}/api{'/v3/' if self.version == 'v3' else '/'}" try: result = requests.get(f"{self.base_url}system/status", params={ "apikey": f"{self.token}" }).json() except Exception: util.print_stacktrace() raise Failed( f"Sonarr Error: Could not connect to Sonarr at {self.url}") if "error" in result and result["error"] == "Unauthorized": raise Failed("Sonarr Error: Invalid API Key") if "version" not in result: raise Failed("Sonarr Error: Unexpected Response Check URL") self.add = params["add"] self.root_folder_path = params["root_folder_path"] self.monitor = params["monitor"] self.quality_profile_id = self.get_profile_id( params["quality_profile"], "quality_profile") self.language_profile_id = None if self.version == "v3" and params["language_profile"] is not None: self.language_profile_id = self.get_profile_id( params["language_profile"], "language_profile") if self.language_profile_id is None: self.language_profile_id = 1 self.series_type = params["series_type"] self.season_folder = params["season_folder"] self.tag = params["tag"] self.tags = self.get_tags() self.search = params["search"] self.cutoff_search = params["cutoff_search"] self.language = language
def anidb_tests(config): if config.AniDB: util.separator("AniDB Tests") try: config.AniDB.get_items("anidb_id", 69, "en", status_message=False) logger.info("Success | Get AniDB ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB ID: {e}") try: config.AniDB.get_items("anidb_relation", 69, "en", status_message=False) logger.info("Success | Get AniDB Relation") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB Relation: {e}") try: config.AniDB.get_items("anidb_popular", 30, "en", status_message=False) logger.info("Success | Get AniDB Popular") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB Popular: {e}") try: config.AniDB.validate_anidb_list(["69", "112"], "en") logger.info("Success | Validate AniDB List") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Validate AniDB List: {e}") else: util.separator("AniDB Not Configured")
def anidb_tests(config): if config.AniDB: util.separator("AniDB Tests") try: config.AniDB.convert_anidb_to_tvdb(69) logger.info("Success | Convert AniDB to TVDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert AniDB to TVDb: {e}") try: config.AniDB.convert_anidb_to_imdb(112) logger.info("Success | Convert AniDB to IMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert AniDB to IMDb: {e}") try: config.AniDB.convert_tvdb_to_anidb(81797) logger.info("Success | Convert TVDb to AniDB") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TVDb to AniDB: {e}") try: config.AniDB.convert_imdb_to_anidb("tt0245429") logger.info("Success | Convert IMDb to AniDB") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert IMDb to AniDB: {e}") try: config.AniDB.get_items("anidb_id", 69, "en", status_message=False) logger.info("Success | Get AniDB ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB ID: {e}") try: config.AniDB.get_items("anidb_relation", 69, "en", status_message=False) logger.info("Success | Get AniDB Relation") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB Relation: {e}") try: config.AniDB.get_items("anidb_popular", 30, "en", status_message=False) logger.info("Success | Get AniDB Popular") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get AniDB Popular: {e}") try: config.AniDB.validate_anidb_list(["69", "112"], "en") logger.info("Success | Validate AniDB List") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Validate AniDB List: {e}") else: util.separator("AniDB Not Configured")
def tmdb_tests(config): if config.TMDb: util.separator("TMDb Tests") try: config.TMDb.convert_imdb_to_tmdb("tt0076759") logger.info("Success | Convert IMDb to TMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert IMDb to TMDb: {e}") try: config.TMDb.convert_tmdb_to_imdb(11) logger.info("Success | Convert TMDb to IMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TMDb to IMDb: {e}") try: config.TMDb.convert_imdb_to_tvdb("tt0458290") logger.info("Success | Convert IMDb to TVDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert IMDb to TVDb: {e}") try: config.TMDb.convert_tvdb_to_imdb(83268) logger.info("Success | Convert TVDb to IMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TVDb to IMDb: {e}") tmdb_list_tests = [([11], "Movie"), ([4194], "Show"), ([10], "Collection"), ([1], "Person"), ([1], "Company"), ([2739], "Network"), ([8136], "List")] for tmdb_list_test in tmdb_list_tests: try: config.TMDb.validate_tmdb_list(tmdb_list_test[0], tmdb_type=tmdb_list_test[1]) logger.info(f"Success | Get TMDb {tmdb_list_test[1]}") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get TMDb {tmdb_list_test[1]}: {e}") tmdb_list_tests = [("tmdb_discover", { "sort_by": "popularity.desc", "limit": 100 }, True), ("tmdb_discover", { "sort_by": "popularity.desc", "limit": 100 }, False), ("tmdb_company", 1, True), ("tmdb_company", 1, False), ("tmdb_network", 2739, False), ("tmdb_keyword", 180547, True), ("tmdb_keyword", 180547, False), ("tmdb_now_playing", 10, True), ("tmdb_popular", 10, True), ("tmdb_popular", 10, False), ("tmdb_top_rated", 10, True), ("tmdb_top_rated", 10, False), ("tmdb_trending_daily", 10, True), ("tmdb_trending_daily", 10, False), ("tmdb_trending_weekly", 10, True), ("tmdb_trending_weekly", 10, False), ("tmdb_list", 7068209, True), ("tmdb_list", 7068209, False), ("tmdb_movie", 11, True), ("tmdb_collection", 10, True), ("tmdb_show", 4194, False)] for tmdb_list_test in tmdb_list_tests: try: config.TMDb.get_items(tmdb_list_test[0], tmdb_list_test[1], tmdb_list_test[2], status_message=False) logger.info( f"Success | Get {'Movies' if tmdb_list_test[2] else 'Shows'} using {util.pretty_names[tmdb_list_test[0]]}" ) except Failed as e: util.print_stacktrace() logger.error( f"Failure | Get {'Movies' if tmdb_list_test[2] else 'Shows'} using {util.pretty_names[tmdb_list_test[0]]}: {e}" ) else: util.separator("TMDb Not Configured")
def mal_tests(config): if config.MyAnimeListIDList: util.separator("MyAnimeListXML Tests") try: config.MyAnimeListIDList.convert_mal_to_tvdb(21) logger.info("Success | Convert MyAnimeList to TVDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert MyAnimeList to TVDb: {e}") try: config.MyAnimeListIDList.convert_mal_to_tmdb(199) logger.info("Success | Convert MyAnimeList to TMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert MyAnimeList to TMDb: {e}") try: config.MyAnimeListIDList.convert_tvdb_to_mal(81797) logger.info("Success | Convert TVDb to MyAnimeList") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TVDb to MyAnimeList: {e}") try: config.MyAnimeListIDList.convert_tmdb_to_mal(129) logger.info("Success | Convert TMDb to MyAnimeList") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TMDb to MyAnimeList: {e}") try: config.MyAnimeListIDList.find_mal_ids(21) logger.info("Success | Find MyAnimeList ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Find MyAnimeList ID: {e}") else: util.separator("MyAnimeListXML Not Configured") if config.MyAnimeList: util.separator("MyAnimeList Tests") mal_list_tests = [("mal_all", 10), ("mal_airing", 10), ("mal_upcoming", 10), ("mal_tv", 10), ("mal_movie", 10), ("mal_ova", 10), ("mal_special", 10), ("mal_popular", 10), ("mal_favorite", 10), ("mal_suggested", 10), ("mal_userlist", { "limit": 10, "username": "******", "status": "completed", "sort_by": "list_score" }), ("mal_season", { "limit": 10, "season": "fall", "year": 2020, "sort_by": "anime_score" })] for mal_list_test in mal_list_tests: try: config.MyAnimeList.get_items(mal_list_test[0], mal_list_test[1], status_message=False) logger.info( f"Success | Get Anime using {util.pretty_names[mal_list_test[0]]}" ) except Failed as e: util.print_stacktrace() logger.error( f"Failure | Get Anime using {util.pretty_names[mal_list_test[0]]}: {e}" ) else: util.separator("MyAnimeList Not Configured")
def get_id(self, item, library): expired = None tmdb_id = [] tvdb_id = [] imdb_id = [] anidb_id = None guid = requests.utils.urlparse(item.guid) item_type = guid.scheme.split(".")[-1] check_id = guid.netloc if self.config.Cache: cache_id, imdb_check, media_type, expired = self.config.Cache.query_guid_map(item.guid) if (cache_id or imdb_check) and not expired: media_id_type = "movie" if "movie" in media_type else "show" if item_type == "hama" and check_id.startswith("anidb"): anidb_id = int(re.search("-(.*)", check_id).group(1)) library.anidb_map[anidb_id] = item.ratingKey elif item_type == "myanimelist": library.mal_map[int(check_id)] = item.ratingKey return media_id_type, cache_id, imdb_check try: if item_type == "plex": try: for guid_tag in item.guids: url_parsed = requests.utils.urlparse(guid_tag.id) if url_parsed.scheme == "tvdb": tvdb_id.append(int(url_parsed.netloc)) elif url_parsed.scheme == "imdb": imdb_id.append(url_parsed.netloc) elif url_parsed.scheme == "tmdb": tmdb_id.append(int(url_parsed.netloc)) except requests.exceptions.ConnectionError: library.query(item.refresh) util.print_stacktrace() raise Failed("No External GUIDs found") if not tvdb_id and not imdb_id and not tmdb_id: library.query(item.refresh) raise Failed("Refresh Metadata") elif item_type == "imdb": imdb_id.append(check_id) elif item_type == "thetvdb": tvdb_id.append(int(check_id)) elif item_type == "themoviedb": tmdb_id.append(int(check_id)) elif item_type == "hama": if check_id.startswith("tvdb"): tvdb_id.append(int(re.search("-(.*)", check_id).group(1))) elif check_id.startswith("anidb"): anidb_str = str(re.search("-(.*)", check_id).group(1)) anidb_id = int(anidb_str[1:] if anidb_str[0] == "a" else anidb_str) library.anidb_map[anidb_id] = item.ratingKey else: raise Failed(f"Hama Agent ID: {check_id} not supported") elif item_type == "myanimelist": library.mal_map[int(check_id)] = item.ratingKey if int(check_id) in self.mal_to_anidb: anidb_id = self.mal_to_anidb[int(check_id)] else: raise Failed(f"Convert Error: AniDB ID not found for MyAnimeList ID: {check_id}") elif item_type == "local": raise Failed("No match in Plex") else: raise Failed(f"Agent {item_type} not supported") if anidb_id: if anidb_id in self.anidb_to_imdb: added = False for imdb in self.anidb_to_imdb[anidb_id]: tmdb, tmdb_type = self.imdb_to_tmdb(imdb) if tmdb and tmdb_type == "movie": imdb_id.append(imdb) tmdb_id.append(tmdb) added = True if added is False and anidb_id in self.anidb_to_tvdb: tvdb_id.append(self.anidb_to_tvdb[anidb_id]) elif anidb_id in self.anidb_to_tvdb: tvdb_id.append(self.anidb_to_tvdb[anidb_id]) else: raise Failed(f"AniDB: {anidb_id} not found") else: if not tmdb_id and imdb_id: for imdb in imdb_id: tmdb, tmdb_type = self.imdb_to_tmdb(imdb) if tmdb and ((tmdb_type == "movie" and library.is_movie) or (tmdb_type == "show" and library.is_show)): tmdb_id.append(tmdb) if not imdb_id and tmdb_id and library.is_movie: for tmdb in tmdb_id: imdb = self.tmdb_to_imdb(tmdb) if imdb: imdb_id.append(imdb) if not tvdb_id and tmdb_id and library.is_show: for tmdb in tmdb_id: tvdb = self.tmdb_to_tvdb(tmdb) if tvdb: tvdb_id.append(tvdb) if not tvdb_id: raise Failed(f"Unable to convert TMDb ID: {', '.join([str(t) for t in tmdb_id])} to TVDb ID") if not imdb_id and tvdb_id: for tvdb in tvdb_id: imdb = self.tvdb_to_imdb(tvdb) if imdb: imdb_id.append(imdb) def update_cache(cache_ids, id_type, imdb_in, guid_type): if self.config.Cache: cache_ids = ",".join([str(c) for c in cache_ids]) imdb_in = ",".join([str(i) for i in imdb_in]) if imdb_in else None ids = f"{item.guid:<46} | {id_type} ID: {cache_ids:<7} | IMDb ID: {str(imdb_in):<10}" logger.info(util.adjust_space(f" Cache | {'^' if expired else '+'} | {ids} | {item.title}")) self.config.Cache.update_guid_map(item.guid, cache_ids, imdb_in, expired, guid_type) if (tmdb_id or imdb_id) and library.is_movie: update_cache(tmdb_id, "TMDb", imdb_id, "movie") return "movie", tmdb_id, imdb_id elif (tvdb_id or imdb_id) and library.is_show: update_cache(tvdb_id, "TVDb", imdb_id, "show") return "show", tvdb_id, imdb_id elif anidb_id and (tmdb_id or imdb_id) and library.is_show: update_cache(tmdb_id, "TMDb", imdb_id, "show_movie") return "movie", tmdb_id, imdb_id else: logger.debug(f"TMDb: {tmdb_id}, IMDb: {imdb_id}, TVDb: {tvdb_id}") raise Failed(f"No ID to convert") except Failed as e: logger.info(util.adjust_space(f'Mapping Error | {item.guid:<46} | {e} for "{item.title}"')) except BadRequest: util.print_stacktrace() logger.info(util.adjust_space(f'Mapping Error | {item.guid:<46} | Bad Request for "{item.title}"')) return None, None, None
def __init__(self, params, TMDb, TVDb): try: self.PlexServer = PlexServer(params["plex"]["url"], params["plex"]["token"], timeout=params["plex"]["timeout"]) except Unauthorized: raise Failed("Plex Error: Plex token is invalid") except ValueError as e: raise Failed(f"Plex Error: {e}") except requests.exceptions.ConnectionError: util.print_stacktrace() raise Failed("Plex Error: Plex url is invalid") self.is_movie = params["library_type"] == "movie" self.is_show = params["library_type"] == "show" self.Plex = next( (s for s in self.PlexServer.library.sections() if s.title == params["name"] and ( (self.is_movie and isinstance(s, MovieSection)) or (self.is_show and isinstance(s, ShowSection)))), None) if not self.Plex: raise Failed( f"Plex Error: Plex Library {params['name']} not found") try: self.data, ind, bsi = yaml.util.load_yaml_guess_indent( open(params["metadata_path"], encoding="utf-8")) except yaml.scanner.ScannerError as e: raise Failed(f"YAML Error: {util.tab_new_lines(e)}") def get_dict(attribute): if attribute in self.data: if self.data[attribute]: if isinstance(self.data[attribute], dict): return self.data[attribute] else: logger.warning( f"Config Warning: {attribute} must be a dictionary" ) else: logger.warning( f"Config Warning: {attribute} attribute is blank") return None self.metadata = get_dict("metadata") self.templates = get_dict("templates") self.collections = get_dict("collections") if self.metadata is None and self.collections is None: raise Failed( "YAML Error: metadata attributes or collections attribute required" ) if params["asset_directory"]: for ad in params["asset_directory"]: logger.info(f"Using Asset Directory: {ad}") self.TMDb = TMDb self.TVDb = TVDb self.Radarr = None self.Sonarr = None self.Tautulli = None self.name = params["name"] self.missing_path = os.path.join( os.path.dirname(os.path.abspath(params["metadata_path"])), f"{os.path.splitext(os.path.basename(params['metadata_path']))[0]}_missing.yml" ) self.metadata_path = params["metadata_path"] self.asset_directory = params["asset_directory"] self.sync_mode = params["sync_mode"] self.show_unmanaged = params["show_unmanaged"] self.show_filtered = params["show_filtered"] self.show_missing = params["show_missing"] self.save_missing = params["save_missing"] self.mass_genre_update = params["mass_genre_update"] self.plex = params["plex"] self.timeout = params["plex"]["timeout"] self.missing = {} self.run_again = []
def update_metadata(self): logger.info("") util.seperator("{} Library Metadata".format(self.name)) logger.info("") if not self.metadata: raise Failed("No metadata to edit") for m in self.metadata: logger.info("") util.seperator() logger.info("") year = None if "year" in self.metadata[m]: now = datetime.datetime.now() if self.metadata[m]["year"] is None: logger.error("Metadata Error: year attribute is blank") elif not isinstance(self.metadata[m]["year"], int): logger.error("Metadata Error: year attribute must be an integer") elif self.metadata[m]["year"] not in range(1800, now.year + 2): logger.error("Metadata Error: year attribute must be between 1800-{}".format(now.year + 1)) else: year = self.metadata[m]["year"] alt_title = None used_alt = False if "alt_title" in self.metadata[m]: if self.metadata[m]["alt_title"] is None: logger.error("Metadata Error: alt_title attribute is blank") else: alt_title = self.metadata[m]["alt_title"] try: item = self.get_item(m, year=year) except Failed as e: if alt_title: try: item = self.get_item(alt_title, year=year) used_alt = True except Failed as alt_e: logger.error(alt_e) logger.error("Skipping {}".format(m)) continue else: logger.error(e) logger.error("Skipping {}".format(m)) continue logger.info("Updating {}: {}...".format("Movie" if self.is_movie else "Show", alt_title if used_alt else m)) edits = {} def add_edit(name, group, key=None, value=None, sub=None): if value or name in group: if value or group[name]: if key is None: key = name if value is None: value = group[name] if sub and "sub" in group: if group["sub"]: if group["sub"] is True and "(SUB)" not in value: value = "{} (SUB)".format(value) elif group["sub"] is False and " (SUB)" in value: value = value[:-6] else: logger.error("Metadata Error: sub attribute is blank") edits["{}.value".format(key)] = value edits["{}.locked".format(key)] = 1 else: logger.error("Metadata Error: {} attribute is blank".format(name)) if used_alt or "sub" in self.metadata[m]: add_edit("title", self.metadata[m], value=m, sub=True) add_edit("sort_title", self.metadata[m], key="titleSort") add_edit("originally_available", self.metadata[m], key="originallyAvailableAt") add_edit("rating", self.metadata[m]) add_edit("content_rating", self.metadata[m], key="contentRating") add_edit("original_title", self.metadata[m], key="originalTitle") add_edit("studio", self.metadata[m]) add_edit("tagline", self.metadata[m]) add_edit("summary", self.metadata[m]) try: item.edit(**edits) item.reload() logger.info("{}: {} Details Update Successful".format("Movie" if self.is_movie else "Show", m)) except BadRequest: logger.error("{}: {} Details Update Failed".format("Movie" if self.is_movie else "Show", m)) logger.debug("Details Update: {}".format(edits)) util.print_stacktrace() if "genre" in self.metadata[m]: if self.metadata[m]["genre"]: genre_sync = False if "genre_sync_mode" in self.metadata[m]: if self.metadata[m]["genre_sync_mode"] is None: logger.error("Metadata Error: genre_sync_mode attribute is blank defaulting to append") elif self.metadata[m]["genre_sync_mode"] not in ["append", "sync"]: logger.error("Metadata Error: genre_sync_mode attribute must be either 'append' or 'sync' defaulting to append") elif self.metadata[m]["genre_sync_mode"] == "sync": genre_sync = True genres = [genre.tag for genre in item.genres] values = util.get_list(self.metadata[m]["genre"]) if genre_sync: for genre in (g for g in genres if g not in values): item.removeGenre(genre) logger.info("Detail: Genre {} removed".format(genre)) for value in (v for v in values if v not in genres): item.addGenre(value) logger.info("Detail: Genre {} added".format(value)) else: logger.error("Metadata Error: genre attribute is blank") if "label" in self.metadata[m]: if self.metadata[m]["label"]: label_sync = False if "label_sync_mode" in self.metadata[m]: if self.metadata[m]["label_sync_mode"] is None: logger.error("Metadata Error: label_sync_mode attribute is blank defaulting to append") elif self.metadata[m]["label_sync_mode"] not in ["append", "sync"]: logger.error("Metadata Error: label_sync_mode attribute must be either 'append' or 'sync' defaulting to append") elif self.metadata[m]["label_sync_mode"] == "sync": label_sync = True labels = [label.tag for label in item.labels] values = util.get_list(self.metadata[m]["label"]) if label_sync: for label in (l for l in labels if l not in values): item.removeLabel(label) logger.info("Detail: Label {} removed".format(label)) for value in (v for v in values if v not in labels): item.addLabel(v) logger.info("Detail: Label {} added".format(v)) else: logger.error("Metadata Error: label attribute is blank") if "seasons" in self.metadata[m] and self.is_show: if self.metadata[m]["seasons"]: for season_id in self.metadata[m]["seasons"]: logger.info("") logger.info("Updating season {} of {}...".format(season_id, alt_title if used_alt else m)) if isinstance(season_id, int): try: season = item.season(season_id) except NotFound: logger.error("Metadata Error: Season: {} not found".format(season_id)) else: edits = {} add_edit("title", self.metadata[m]["seasons"][season_id], sub=True) add_edit("summary", self.metadata[m]["seasons"][season_id]) try: season.edit(**edits) season.reload() logger.info("Season: {} Details Update Successful".format(season_id)) except BadRequest: logger.debug("Season: {} Details Update: {}".format(season_id, edits)) logger.error("Season: {} Details Update Failed".format(season_id)) util.print_stacktrace() else: logger.error("Metadata Error: Season: {} invalid, it must be an integer".format(season_id)) else: logger.error("Metadata Error: seasons attribute is blank") if "episodes" in self.metadata[m] and self.is_show: if self.metadata[m]["episodes"]: for episode_str in self.metadata[m]["episodes"]: logger.info("") match = re.search("[Ss]{1}\d+[Ee]{1}\d+", episode_str) if match: output = match.group(0)[1:].split("E" if "E" in m.group(0) else "e") episode_id = int(output[0]) season_id = int(output[1]) logger.info("Updating episode S{}E{} of {}...".format(episode_id, season_id, alt_title if used_alt else m)) try: episode = item.episode(season=season_id, episode=episode_id) except NotFound: logger.error("Metadata Error: episode {} of season {} not found".format(episode_id, season_id)) else: edits = {} add_edit("title", self.metadata[m]["episodes"][episode_str], sub=True) add_edit("sort_title", self.metadata[m]["episodes"][episode_str], key="titleSort") add_edit("rating", self.metadata[m]["episodes"][episode_str]) add_edit("originally_available", self.metadata[m]["episodes"][episode_str], key="originallyAvailableAt") add_edit("summary", self.metadata[m]["episodes"][episode_str]) try: episode.edit(**edits) episode.reload() logger.info("Season: {} Episode: {} Details Update Successful".format(season_id, episode_id)) except BadRequest: logger.debug("Season: {} Episode: {} Details Update: {}".format(season_id, episode_id, edits)) logger.error("Season: {} Episode: {} Details Update Failed".format(season_id, episode_id)) util.print_stacktrace() else: logger.error("Metadata Error: episode {} invlaid must have S##E## format".format(episode_str)) else: logger.error("Metadata Error: episodes attribute is blank")
def __init__(self, params): try: self.PlexServer = PlexServer(params["plex"]["url"], params["plex"]["token"], timeout=600) except Unauthorized: raise Failed("Plex Error: Plex token is invalid") except ValueError as e: raise Failed("Plex Error: {}".format(e)) except requests.exceptions.ConnectionError as e: util.print_stacktrace() raise Failed("Plex Error: Plex url is invalid") self.is_movie = params["library_type"] == "movie" self.is_show = params["library_type"] == "show" self.Plex = next((s for s in self.PlexServer.library.sections() if s.title == params["name"] and ((self.is_movie and isinstance(s, MovieSection)) or (self.is_show and isinstance(s, ShowSection)))), None) if not self.Plex: raise Failed("Plex Error: Plex Library {} not found".format(params["name"])) try: self.data, ind, bsi = yaml.util.load_yaml_guess_indent(open(params["metadata_path"], encoding="utf-8")) except yaml.scanner.ScannerError as e: raise Failed("YAML Error: {}".format(str(e).replace("\n", "\n|\t "))) self.metadata = None if "metadata" in self.data: if self.data["metadata"]: self.metadata = self.data["metadata"] else: logger.warning("Config Warning: metadata attribute is blank") else: logger.warning("Config Warning: metadata attribute not found") self.collections = None if "collections" in self.data: if self.data["collections"]: self.collections = self.data["collections"] else: logger.warning("Config Warning: collections attribute is blank") else: logger.warning("Config Warning: collections attribute not found") if self.metadata is None and self.collections is None: raise Failed("YAML Error: metadata attributes or collections attribute required") if params["asset_directory"]: logger.info("Using Asset Directory: {}".format(params["asset_directory"])) self.Radarr = None if params["tmdb"] and params["radarr"]: logger.info("Connecting to {} library's Radarr...".format(params["name"])) try: self.Radarr = RadarrAPI(params["tmdb"], params["radarr"]) except Failed as e: logger.error(e) logger.info("{} library's Radarr Connection {}".format(params["name"], "Failed" if self.Radarr is None else "Successful")) self.Sonarr = None if params["tvdb"] and params["sonarr"]: logger.info("Connecting to {} library's Sonarr...".format(params["name"])) try: self.Sonarr = SonarrAPI(params["tvdb"], params["sonarr"], self.Plex.language) except Failed as e: logger.error(e) logger.info("{} library's Sonarr Connection {}".format(params["name"], "Failed" if self.Sonarr is None else "Successful")) self.Tautulli = None if params["tautulli"]: logger.info("Connecting to {} library's Tautulli...".format(params["name"])) try: self.Tautulli = TautulliAPI(params["tautulli"]) except Failed as e: logger.error(e) logger.info("{} library's Tautulli Connection {}".format(params["name"], "Failed" if self.Tautulli is None else "Successful")) self.name = params["name"] self.missing_path = os.path.join(os.path.dirname(os.path.abspath(params["metadata_path"])), "{}_missing.yml".format(os.path.splitext(os.path.basename(params["metadata_path"]))[0])) self.metadata_path = params["metadata_path"] self.asset_directory = params["asset_directory"] self.sync_mode = params["sync_mode"] self.plex = params["plex"] self.radarr = params["radarr"] self.sonarr = params["sonarr"] self.tautulli = params["tautulli"]
def update_metadata(self, TMDb, test): logger.info("") util.separator(f"{self.name} Library Metadata") logger.info("") if not self.metadata: raise Failed("No metadata to edit") for mapping_name, meta in self.metadata.items(): methods = {mm.lower(): mm for mm in meta} if test and ("test" not in methods or meta[methods["test"]] is not True): continue logger.info("") util.separator() logger.info("") year = None if "year" in methods: year = util.check_number(meta[methods["year"]], "year", minimum=1800, maximum=datetime.now().year + 1) title = mapping_name if "title" in methods: if meta[methods["title"]] is None: logger.error("Metadata Error: title attribute is blank") else: title = meta[methods["title"]] item = self.search_item(title, year=year) if item is None: item = self.search_item(f"{title} (SUB)", year=year) if item is None and "alt_title" in methods: if meta[methods["alt_title"]] is None: logger.error("Metadata Error: alt_title attribute is blank") else: alt_title = meta["alt_title"] item = self.search_item(alt_title, year=year) if item is None: logger.error(f"Plex Error: Item {mapping_name} not found") logger.error(f"Skipping {mapping_name}") continue item_type = "Movie" if self.is_movie else "Show" logger.info(f"Updating {item_type}: {title}...") tmdb_item = None try: if "tmdb_id" in methods: if meta[methods["tmdb_id"]] is None: logger.error("Metadata Error: tmdb_id attribute is blank") elif self.is_show: logger.error("Metadata Error: tmdb_id attribute only works with movie libraries") else: tmdb_item = TMDb.get_show(util.regex_first_int(meta[methods["tmdb_id"]], "Show")) except Failed as e: logger.error(e) originally_available = tmdb_item.first_air_date if tmdb_item else None rating = tmdb_item.vote_average if tmdb_item else None original_title = tmdb_item.original_name if tmdb_item and tmdb_item.original_name != tmdb_item.name else None studio = tmdb_item.networks[0].name if tmdb_item else None tagline = tmdb_item.tagline if tmdb_item and len(tmdb_item.tagline) > 0 else None summary = tmdb_item.overview if tmdb_item else None details_updated = False advance_details_updated = False genre_updated = False label_updated = False season_updated = False episode_updated = False edits = {} def add_edit(name, current, group, alias, key=None, value=None): if value or name in alias: if value or group[alias[name]]: if key is None: key = name if value is None: value = group[alias[name]] if str(current) != str(value): edits[f"{key}.value"] = value edits[f"{key}.locked"] = 1 logger.info(f"Detail: {name} updated to {value}") else: logger.error(f"Metadata Error: {name} attribute is blank") add_edit("title", item.title, meta, methods, value=title) add_edit("sort_title", item.titleSort, meta, methods, key="titleSort") add_edit("originally_available", str(item.originallyAvailableAt)[:-9], meta, methods, key="originallyAvailableAt", value=originally_available) add_edit("rating", item.rating, meta, methods, value=rating) add_edit("content_rating", item.contentRating, meta, methods, key="contentRating") add_edit("original_title", item.originalTitle, meta, methods, key="originalTitle", value=original_title) add_edit("studio", item.studio, meta, methods, value=studio) add_edit("tagline", item.tagline, meta, methods, value=tagline) add_edit("summary", item.summary, meta, methods, value=summary) if len(edits) > 0: logger.debug(f"Details Update: {edits}") details_updated = True try: item.edit(**edits) item.reload() logger.info(f"{item_type}: {mapping_name} Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"{item_type}: {mapping_name} Details Update Failed") advance_edits = {} if self.is_show: if "episode_sorting" in methods: if meta[methods["episode_sorting"]]: method_data = str(meta[methods["episode_sorting"]]).lower() if method_data in ["default", "oldest", "newest"]: if method_data == "default" and item.episodeSort != "-1": advance_edits["episodeSort"] = "-1" elif method_data == "oldest" and item.episodeSort != "0": advance_edits["episodeSort"] = "0" elif method_data == "newest" and item.episodeSort != "1": advance_edits["episodeSort"] = "1" if "episodeSort" in advance_edits: logger.info(f"Detail: episode_sorting updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['episode_sorting']]} episode_sorting attribute invalid") else: logger.error(f"Metadata Error: episode_sorting attribute is blank") if "keep_episodes" in methods: if meta[methods["keep_episodes"]]: method_data = str(meta[methods["keep_episodes"]]).lower() if method_data in ["all", "5_latest", "3_latest", "latest", "past_3", "past_7", "past_30"]: if method_data == "all" and item.autoDeletionItemPolicyUnwatchedLibrary != 0: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = 0 elif method_data == "5_latest" and item.autoDeletionItemPolicyUnwatchedLibrary != 5: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = 5 elif method_data == "3_latest" and item.autoDeletionItemPolicyUnwatchedLibrary != 3: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = 3 elif method_data == "latest" and item.autoDeletionItemPolicyUnwatchedLibrary != 1: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = 1 elif method_data == "past_3" and item.autoDeletionItemPolicyUnwatchedLibrary != -3: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = -3 elif method_data == "past_7" and item.autoDeletionItemPolicyUnwatchedLibrary != -7: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = -7 elif method_data == "past_30" and item.autoDeletionItemPolicyUnwatchedLibrary != -30: advance_edits["autoDeletionItemPolicyUnwatchedLibrary"] = -30 if "autoDeletionItemPolicyUnwatchedLibrary" in advance_edits: logger.info(f"Detail: keep_episodes updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['keep_episodes']]} keep_episodes attribute invalid") else: logger.error(f"Metadata Error: keep_episodes attribute is blank") if "delete_episodes" in methods: if meta[methods["delete_episodes"]]: method_data = str(meta[methods["delete_episodes"]]).lower() if method_data in ["never", "day", "week", "refresh"]: if method_data == "never" and item.autoDeletionItemPolicyWatchedLibrary != 0: advance_edits["autoDeletionItemPolicyWatchedLibrary"] = 0 elif method_data == "day" and item.autoDeletionItemPolicyWatchedLibrary != 1: advance_edits["autoDeletionItemPolicyWatchedLibrary"] = 1 elif method_data == "week" and item.autoDeletionItemPolicyWatchedLibrary != 7: advance_edits["autoDeletionItemPolicyWatchedLibrary"] = 7 elif method_data == "refresh" and item.autoDeletionItemPolicyWatchedLibrary != 100: advance_edits["autoDeletionItemPolicyWatchedLibrary"] = 100 if "autoDeletionItemPolicyWatchedLibrary" in advance_edits: logger.info(f"Detail: delete_episodes updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['delete_episodes']]} delete_episodes attribute invalid") else: logger.error(f"Metadata Error: delete_episodes attribute is blank") if "season_display" in methods: if meta[methods["season_display"]]: method_data = str(meta[methods["season_display"]]).lower() if method_data in ["default", "hide", "show"]: if method_data == "default" and item.flattenSeasons != -1: advance_edits["flattenSeasons"] = -1 elif method_data == "show" and item.flattenSeasons != 0: advance_edits["flattenSeasons"] = 0 elif method_data == "hide" and item.flattenSeasons != 1: advance_edits["flattenSeasons"] = 1 if "flattenSeasons" in advance_edits: logger.info(f"Detail: season_display updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['season_display']]} season_display attribute invalid") else: logger.error(f"Metadata Error: season_display attribute is blank") if "episode_ordering" in methods: if meta[methods["episode_ordering"]]: method_data = str(meta[methods["episode_ordering"]]).lower() if method_data in ["default", "tmdb_aired", "tvdb_aired", "tvdb_dvd", "tvdb_absolute"]: if method_data == "default" and item.showOrdering is not None: advance_edits["showOrdering"] = None elif method_data == "tmdb_aired" and item.showOrdering != "tmdbAiring": advance_edits["showOrdering"] = "tmdbAiring" elif method_data == "tvdb_aired" and item.showOrdering != "airing": advance_edits["showOrdering"] = "airing" elif method_data == "tvdb_dvd" and item.showOrdering != "dvd": advance_edits["showOrdering"] = "dvd" elif method_data == "tvdb_absolute" and item.showOrdering != "absolute": advance_edits["showOrdering"] = "absolute" if "showOrdering" in advance_edits: logger.info(f"Detail: episode_ordering updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['episode_ordering']]} episode_ordering attribute invalid") else: logger.error(f"Metadata Error: episode_ordering attribute is blank") if "metadata_language" in methods: if meta[methods["metadata_language"]]: method_data = str(meta[methods["metadata_language"]]).lower() lower_languages = {la.lower(): la for la in util.plex_languages} if method_data in lower_languages: if method_data == "default" and item.languageOverride is None: advance_edits["languageOverride"] = None elif str(item.languageOverride).lower() != lower_languages[method_data]: advance_edits["languageOverride"] = lower_languages[method_data] if "languageOverride" in advance_edits: logger.info(f"Detail: metadata_language updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['metadata_language']]} metadata_language attribute invalid") else: logger.error(f"Metadata Error: metadata_language attribute is blank") if "use_original_title" in methods: if meta[methods["use_original_title"]]: method_data = str(meta[methods["use_original_title"]]).lower() if method_data in ["default", "no", "yes"]: if method_data == "default" and item.useOriginalTitle != -1: advance_edits["useOriginalTitle"] = -1 elif method_data == "no" and item.useOriginalTitle != 0: advance_edits["useOriginalTitle"] = 0 elif method_data == "yes" and item.useOriginalTitle != 1: advance_edits["useOriginalTitle"] = 1 if "useOriginalTitle" in advance_edits: logger.info(f"Detail: use_original_title updated to {method_data}") else: logger.error(f"Metadata Error: {meta[methods['use_original_title']]} use_original_title attribute invalid") else: logger.error(f"Metadata Error: use_original_title attribute is blank") if len(advance_edits) > 0: logger.debug(f"Details Update: {advance_edits}") advance_details_updated = True try: check_dict = {pref.id: list(pref.enumValues.keys()) for pref in item.preferences()} logger.info(check_dict) item.editAdvanced(**advance_edits) item.reload() logger.info(f"{item_type}: {mapping_name} Advanced Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"{item_type}: {mapping_name} Advanced Details Update Failed") genres = [] if tmdb_item: genres.extend([genre.name for genre in tmdb_item.genres]) if "genre" in methods: if meta[methods["genre"]]: genres.extend(util.get_list(meta[methods["genre"]])) else: logger.error("Metadata Error: genre attribute is blank") if len(genres) > 0: item_genres = [genre.tag for genre in item.genres] if "genre_sync_mode" in methods: if meta[methods["genre_sync_mode"]] is None: logger.error("Metadata Error: genre_sync_mode attribute is blank defaulting to append") elif str(meta[methods["genre_sync_mode"]]).lower() not in ["append", "sync"]: logger.error("Metadata Error: genre_sync_mode attribute must be either 'append' or 'sync' defaulting to append") elif str(meta["genre_sync_mode"]).lower() == "sync": for genre in (g for g in item_genres if g not in genres): genre_updated = True item.removeGenre(genre) logger.info(f"Detail: Genre {genre} removed") for genre in (g for g in genres if g not in item_genres): genre_updated = True item.addGenre(genre) logger.info(f"Detail: Genre {genre} added") if "label" in methods: if meta[methods["label"]]: item_labels = [label.tag for label in item.labels] labels = util.get_list(meta[methods["label"]]) if "label_sync_mode" in methods: if meta[methods["label_sync_mode"]] is None: logger.error("Metadata Error: label_sync_mode attribute is blank defaulting to append") elif str(meta[methods["label_sync_mode"]]).lower() not in ["append", "sync"]: logger.error("Metadata Error: label_sync_mode attribute must be either 'append' or 'sync' defaulting to append") elif str(meta[methods["label_sync_mode"]]).lower() == "sync": for label in (la for la in item_labels if la not in labels): label_updated = True item.removeLabel(label) logger.info(f"Detail: Label {label} removed") for label in (la for la in labels if la not in item_labels): label_updated = True item.addLabel(label) logger.info(f"Detail: Label {label} added") else: logger.error("Metadata Error: label attribute is blank") if "seasons" in methods and self.is_show: if meta[methods["seasons"]]: for season_id in meta[methods["seasons"]]: logger.info("") logger.info(f"Updating season {season_id} of {mapping_name}...") if isinstance(season_id, int): try: season = item.season(season_id) except NotFound: logger.error(f"Metadata Error: Season: {season_id} not found") else: season_dict = meta[methods["seasons"]][season_id] season_methods = {sm.lower(): sm for sm in season_dict} if "title" in season_methods and season_dict[season_methods["title"]]: title = season_dict[season_methods["title"]] else: title = season.title if "sub" in season_methods: if season_dict[season_methods["sub"]] is None: logger.error("Metadata Error: sub attribute is blank") elif season_dict[season_methods["sub"]] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif season_dict[season_methods["sub"]] is False and title.endswith(" (SUB)"): title = title[:-6] else: logger.error("Metadata Error: sub attribute must be True or False") edits = {} add_edit("title", season.title, season_dict, season_methods, value=title) add_edit("summary", season.summary, season_methods, season_dict) if len(edits) > 0: logger.debug(f"Season: {season_id} Details Update: {edits}") season_updated = True try: season.edit(**edits) season.reload() logger.info(f"Season: {season_id} Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"Season: {season_id} Details Update Failed") else: logger.error(f"Metadata Error: Season: {season_id} invalid, it must be an integer") else: logger.error("Metadata Error: seasons attribute is blank") if "episodes" in methods and self.is_show: if meta[methods["episodes"]]: for episode_str in meta[methods["episodes"]]: logger.info("") match = re.search("[Ss]\\d+[Ee]\\d+", episode_str) if match: output = match.group(0)[1:].split("E" if "E" in match.group(0) else "e") episode_id = int(output[0]) season_id = int(output[1]) logger.info(f"Updating episode S{episode_id}E{season_id} of {mapping_name}...") try: episode = item.episode(season=season_id, episode=episode_id) except NotFound: logger.error(f"Metadata Error: episode {episode_id} of season {season_id} not found") else: episode_dict = meta[methods["episodes"]][episode_str] episode_methods = {em.lower(): em for em in episode_dict} if "title" in episode_methods and episode_dict[episode_methods["title"]]: title = episode_dict[episode_methods["title"]] else: title = episode.title if "sub" in episode_dict: if episode_dict[episode_methods["sub"]] is None: logger.error("Metadata Error: sub attribute is blank") elif episode_dict[episode_methods["sub"]] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif episode_dict[episode_methods["sub"]] is False and title.endswith(" (SUB)"): title = title[:-6] else: logger.error("Metadata Error: sub attribute must be True or False") edits = {} add_edit("title", episode.title, episode_dict, episode_methods, value=title) add_edit("sort_title", episode.titleSort, episode_dict, episode_methods, key="titleSort") add_edit("rating", episode.rating, episode_dict, episode_methods) add_edit("originally_available", str(episode.originallyAvailableAt)[:-9], episode_dict, episode_methods, key="originallyAvailableAt") add_edit("summary", episode.summary, episode_dict, episode_methods) if len(edits) > 0: logger.debug(f"Season: {season_id} Episode: {episode_id} Details Update: {edits}") episode_updated = True try: episode.edit(**edits) episode.reload() logger.info( f"Season: {season_id} Episode: {episode_id} Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"Season: {season_id} Episode: {episode_id} Details Update Failed") else: logger.error(f"Metadata Error: episode {episode_str} invalid must have S##E## format") else: logger.error("Metadata Error: episodes attribute is blank") if not details_updated and not advance_details_updated and not genre_updated and not label_updated and not season_updated and not episode_updated: logger.info(f"{item_type}: {mapping_name} Details Update Not Needed")
def update_metadata(self, TMDb, test): logger.info("") util.separator(f"{self.name} Library Metadata") logger.info("") if not self.metadata: raise Failed("No metadata to edit") for mapping_name, meta in self.metadata.items(): methods = {mm.lower(): mm for mm in meta} if test and ("test" not in methods or meta[methods["test"]] is not True): continue logger.info("") util.separator() logger.info("") year = None if "year" in methods: year = util.check_number(meta[methods["year"]], "year", minimum=1800, maximum=datetime.now().year + 1) title = mapping_name if "title" in methods: if meta[methods["title"]] is None: logger.error("Metadata Error: title attribute is blank") else: title = meta[methods["title"]] item = self.search_item(title, year=year) if item is None: item = self.search_item(f"{title} (SUB)", year=year) if item is None and "alt_title" in methods: if meta[methods["alt_title"]] is None: logger.error( "Metadata Error: alt_title attribute is blank") else: alt_title = meta["alt_title"] item = self.search_item(alt_title, year=year) if item is None: logger.error(f"Plex Error: Item {mapping_name} not found") logger.error(f"Skipping {mapping_name}") continue item_type = "Movie" if self.is_movie else "Show" logger.info(f"Updating {item_type}: {title}...") tmdb_item = None try: if "tmdb_id" in methods: if meta[methods["tmdb_id"]] is None: logger.error( "Metadata Error: tmdb_id attribute is blank") elif self.is_show: logger.error( "Metadata Error: tmdb_id attribute only works with movie libraries" ) else: tmdb_item = TMDb.get_show( util.regex_first_int(meta[methods["tmdb_id"]], "Show")) except Failed as e: logger.error(e) originally_available = tmdb_item.first_air_date if tmdb_item else None rating = tmdb_item.vote_average if tmdb_item else None original_title = tmdb_item.original_name if tmdb_item and tmdb_item.original_name != tmdb_item.name else None studio = tmdb_item.networks[0].name if tmdb_item else None tagline = tmdb_item.tagline if tmdb_item and len( tmdb_item.tagline) > 0 else None summary = tmdb_item.overview if tmdb_item else None updated = False edits = {} def add_edit(name, current, group, alias, key=None, value=None, var_type="str"): if value or name in alias: if value or group[alias[name]]: if key is None: key = name if value is None: value = group[alias[name]] try: if var_type == "date": final_value = util.check_date( value, name, return_string=True, plex_date=True) elif var_type == "float": final_value = util.check_number( value, name, number_type="float", minimum=0, maximum=10) else: final_value = value if str(current) != str(final_value): edits[f"{key}.value"] = final_value edits[f"{key}.locked"] = 1 logger.info( f"Detail: {name} updated to {final_value}") except Failed as ee: logger.error(ee) else: logger.error( f"Metadata Error: {name} attribute is blank") add_edit("title", item.title, meta, methods, value=title) add_edit("sort_title", item.titleSort, meta, methods, key="titleSort") add_edit("originally_available", str(item.originallyAvailableAt)[:-9], meta, methods, key="originallyAvailableAt", value=originally_available, var_type="date") add_edit("critic_rating", item.rating, meta, methods, value=rating, key="rating", var_type="float") add_edit("audience_rating", item.audienceRating, meta, methods, key="audienceRating", var_type="float") add_edit("content_rating", item.contentRating, meta, methods, key="contentRating") add_edit("original_title", item.originalTitle, meta, methods, key="originalTitle", value=original_title) add_edit("studio", item.studio, meta, methods, value=studio) add_edit("tagline", item.tagline, meta, methods, value=tagline) add_edit("summary", item.summary, meta, methods, value=summary) if len(edits) > 0: logger.debug(f"Details Update: {edits}") updated = True try: item.edit(**edits) item.reload() logger.info( f"{item_type}: {mapping_name} Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"{item_type}: {mapping_name} Details Update Failed") advance_edits = {} def add_advanced_edit(attr, options, key=None, show_library=False): if key is None: key = attr if attr in methods: if show_library and not self.is_show: logger.error( f"Metadata Error: {attr} attribute only works for show libraries" ) elif meta[methods[attr]]: method_data = str(meta[methods[attr]]).lower() if method_data in options and getattr( item, key) != options[method_data]: advance_edits[key] = options[method_data] logger.info( f"Detail: {attr} updated to {method_data}") else: logger.error( f"Metadata Error: {meta[methods[attr]]} {attr} attribute invalid" ) else: logger.error( f"Metadata Error: {attr} attribute is blank") add_advanced_edit("episode_sorting", episode_sorting_options, key="episodeSort", show_library=True) add_advanced_edit("keep_episodes", keep_episodes_options, key="autoDeletionItemPolicyUnwatchedLibrary", show_library=True) add_advanced_edit("delete_episodes", delete_episodes_options, key="autoDeletionItemPolicyWatchedLibrary", show_library=True) add_advanced_edit("season_display", season_display_options, key="flattenSeasons", show_library=True) add_advanced_edit("episode_ordering", episode_ordering_options, key="showOrdering", show_library=True) add_advanced_edit("metadata_language", metadata_language_options, key="languageOverride") add_advanced_edit("use_original_title", use_original_title_options, key="useOriginalTitle") if len(advance_edits) > 0: logger.debug(f"Details Update: {advance_edits}") updated = True try: check_dict = { pref.id: list(pref.enumValues.keys()) for pref in item.preferences() } logger.info(check_dict) item.editAdvanced(**advance_edits) item.reload() logger.info( f"{item_type}: {mapping_name} Advanced Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"{item_type}: {mapping_name} Advanced Details Update Failed" ) def edit_tags(attr, obj, key=None, extra=None, movie_library=False): if key is None: key = f"{attr}s" if attr in methods and f"{attr}.sync" in methods: logger.error( f"Metadata Error: Cannot use {attr} and {attr}.sync together" ) elif attr in methods or f"{attr}.sync" in methods: attr_key = attr if attr in methods else f"{attr}.sync" if movie_library and not self.is_movie: logger.error( f"Metadata Error: {attr_key} attribute only works for movie libraries" ) elif meta[methods[attr_key]] or extra: item_tags = [ item_tag.tag for item_tag in getattr(obj, key) ] input_tags = [] if meta[methods[attr_key]]: input_tags.extend( util.get_list(meta[methods[attr_key]])) if extra: input_tags.extend(extra) if f"{attr}.sync" in methods: remove_method = getattr( obj, f"remove{attr.capitalize()}") for tag in (t for t in item_tags if t not in input_tags): updated = True remove_method(tag) logger.info( f"Detail: {attr.capitalize()} {tag} removed" ) add_method = getattr(obj, f"add{attr.capitalize()}") for tag in (t for t in input_tags if t not in item_tags): updated = True add_method(tag) logger.info( f"Detail: {attr.capitalize()} {tag} added") else: logger.error( f"Metadata Error: {attr} attribute is blank") genres = [genre.name for genre in tmdb_item.genres] if tmdb_item else [] edit_tags("genre", item, extra=genres) edit_tags("label", item) edit_tags("collection", item) edit_tags("country", item, key="countries", movie_library=True) edit_tags("director", item, movie_library=True) edit_tags("producer", item, movie_library=True) edit_tags("writer", item, movie_library=True) if "seasons" in methods and self.is_show: if meta[methods["seasons"]]: for season_id in meta[methods["seasons"]]: logger.info("") logger.info( f"Updating season {season_id} of {mapping_name}..." ) if isinstance(season_id, int): try: season = item.season(season_id) except NotFound: logger.error( f"Metadata Error: Season: {season_id} not found" ) else: season_dict = meta[ methods["seasons"]][season_id] season_methods = { sm.lower(): sm for sm in season_dict } if "title" in season_methods and season_dict[ season_methods["title"]]: title = season_dict[ season_methods["title"]] else: title = season.title if "sub" in season_methods: if season_dict[ season_methods["sub"]] is None: logger.error( "Metadata Error: sub attribute is blank" ) elif season_dict[season_methods[ "sub"]] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif season_dict[season_methods[ "sub"]] is False and title.endswith( " (SUB)"): title = title[:-6] else: logger.error( "Metadata Error: sub attribute must be True or False" ) edits = {} add_edit("title", season.title, season_dict, season_methods, value=title) add_edit("summary", season.summary, season_methods, season_dict) if len(edits) > 0: logger.debug( f"Season: {season_id} Details Update: {edits}" ) updated = True try: season.edit(**edits) season.reload() logger.info( f"Season: {season_id} Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"Season: {season_id} Details Update Failed" ) else: logger.error( f"Metadata Error: Season: {season_id} invalid, it must be an integer" ) else: logger.error("Metadata Error: seasons attribute is blank") elif "seasons" in methods: logger.error( "Metadata Error: seasons attribute only works for show libraries" ) if "episodes" in methods and self.is_show: if meta[methods["episodes"]]: for episode_str in meta[methods["episodes"]]: logger.info("") match = re.search("[Ss]\\d+[Ee]\\d+", episode_str) if match: output = match.group(0)[1:].split( "E" if "E" in match.group(0) else "e") season_id = int(output[0]) episode_id = int(output[1]) logger.info( f"Updating episode S{episode_id}E{season_id} of {mapping_name}..." ) try: episode = item.episode(season=season_id, episode=episode_id) except NotFound: logger.error( f"Metadata Error: episode {episode_id} of season {season_id} not found" ) else: episode_dict = meta[ methods["episodes"]][episode_str] episode_methods = { em.lower(): em for em in episode_dict } if "title" in episode_methods and episode_dict[ episode_methods["title"]]: title = episode_dict[ episode_methods["title"]] else: title = episode.title if "sub" in episode_dict: if episode_dict[ episode_methods["sub"]] is None: logger.error( "Metadata Error: sub attribute is blank" ) elif episode_dict[episode_methods[ "sub"]] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif episode_dict[episode_methods[ "sub"]] is False and title.endswith( " (SUB)"): title = title[:-6] else: logger.error( "Metadata Error: sub attribute must be True or False" ) edits = {} add_edit("title", episode.title, episode_dict, episode_methods, value=title) add_edit("sort_title", episode.titleSort, episode_dict, episode_methods, key="titleSort") add_edit("rating", episode.rating, episode_dict, episode_methods) add_edit( "originally_available", str(episode.originallyAvailableAt)[:-9], episode_dict, episode_methods, key="originallyAvailableAt") add_edit("summary", episode.summary, episode_dict, episode_methods) if len(edits) > 0: logger.debug( f"Season: {season_id} Episode: {episode_id} Details Update: {edits}" ) updated = True try: episode.edit(**edits) episode.reload() logger.info( f"Season: {season_id} Episode: {episode_id} Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"Season: {season_id} Episode: {episode_id} Details Update Failed" ) edit_tags("director", episode) edit_tags("writer", episode) else: logger.error( f"Metadata Error: episode {episode_str} invalid must have S##E## format" ) else: logger.error("Metadata Error: episodes attribute is blank") elif "episodes" in methods: logger.error( "Metadata Error: episodes attribute only works for show libraries" ) if not updated: logger.info( f"{item_type}: {mapping_name} Details Update Not Needed")
def trakt_tests(config): if config.Trakt: util.separator("Trakt Tests") try: config.Trakt.convert_imdb_to_tmdb("tt0076759") logger.info("Success | Convert IMDb to TMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert IMDb to TMDb: {e}") try: config.Trakt.convert_tmdb_to_imdb(11) logger.info("Success | Convert TMDb to IMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TMDb to IMDb: {e}") try: config.Trakt.convert_imdb_to_tvdb("tt0458290") logger.info("Success | Convert IMDb to TVDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert IMDb to TVDb: {e}") try: config.Trakt.convert_tvdb_to_imdb(83268) logger.info("Success | Convert TVDb to IMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TVDb to IMDb: {e}") try: config.Trakt.convert_tmdb_to_tvdb(11) logger.info("Success | Convert TMDb to TVDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TMDb to TVDb: {e}") try: config.Trakt.convert_tvdb_to_tmdb(83268) logger.info("Success | Convert TVDb to TMDb") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Convert TVDb to TMDb: {e}") try: config.Trakt.validate_trakt_list( ["https://trakt.tv/users/movistapp/lists/christmas-movies"]) logger.info("Success | Get List") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get List: {e}") try: config.Trakt.validate_trakt_watchlist(["me"], True) logger.info("Success | Get Watchlist Movies") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get Watchlist Movies: {e}") try: config.Trakt.validate_trakt_watchlist(["me"], False) logger.info("Success | Get Watchlist Shows") except Failed as e: util.print_stacktrace() logger.error(f"Failure | Get Watchlist Shows: {e}") trakt_list_tests = [ ("trakt_list", "https://trakt.tv/users/movistapp/lists/christmas-movies", True), ("trakt_trending", 10, True), ("trakt_trending", 10, False), ("trakt_watchlist", "me", True), ("trakt_watchlist", "me", False) ] for trakt_list_test in trakt_list_tests: try: config.Trakt.get_items(trakt_list_test[0], trakt_list_test[1], trakt_list_test[2], status_message=False) logger.info( f"Success | Get {'Movies' if trakt_list_test[2] else 'Shows'} using {util.pretty_names[trakt_list_test[0]]}" ) except Failed as e: util.print_stacktrace() logger.error( f"Failure | Get {'Movies' if trakt_list_test[2] else 'Shows'} using {util.pretty_names[trakt_list_test[0]]}: {e}" ) else: util.separator("Trakt Not Configured")
def update_metadata(self, TMDb, test): logger.info("") util.separator(f"{self.name} Library Metadata") logger.info("") if not self.metadata: raise Failed("No metadata to edit") for m in self.metadata: if test and ("test" not in self.metadata[m] or self.metadata[m]["test"] is not True): continue logger.info("") util.separator() logger.info("") year = None if "year" in self.metadata[m]: year = util.check_number(self.metadata[m]["year"], "year", minimum=1800, maximum=datetime.now().year + 1) title = m if "title" in self.metadata[m]: if self.metadata[m]["title"] is None: logger.error("Metadata Error: title attribute is blank") else: title = self.metadata[m]["title"] item = self.search_item(title, year=year) if item is None: item = self.search_item(f"{title} (SUB)", year=year) if item is None and "alt_title" in self.metadata[m]: if self.metadata[m]["alt_title"] is None: logger.error( "Metadata Error: alt_title attribute is blank") else: alt_title = self.metadata[m]["alt_title"] item = self.search_item(alt_title, year=year) if item is None: logger.error(f"Plex Error: Item {m} not found") logger.error(f"Skipping {m}") continue item_type = "Movie" if self.is_movie else "Show" logger.info(f"Updating {item_type}: {title}...") tmdb_item = None try: if "tmdb_id" in self.metadata[m]: if self.metadata[m]["tmdb_id"] is None: logger.error( "Metadata Error: tmdb_id attribute is blank") elif self.is_show: logger.error( "Metadata Error: tmdb_id attribute only works with movie libraries" ) else: tmdb_item = TMDb.get_show( util.regex_first_int(self.metadata[m]["tmdb_id"], "Show")) except Failed as e: logger.error(e) originally_available = tmdb_item.first_air_date if tmdb_item else None rating = tmdb_item.vote_average if tmdb_item else None original_title = tmdb_item.original_name if tmdb_item and tmdb_item.original_name != tmdb_item.name else None studio = tmdb_item.networks[0].name if tmdb_item else None tagline = tmdb_item.tagline if tmdb_item and len( tmdb_item.tagline) > 0 else None summary = tmdb_item.overview if tmdb_item else None edits = {} def add_edit(name, current, group, key=None, value=None): if value or name in group: if value or group[name]: if key is None: key = name if value is None: value = group[name] if str(current) != str(value): edits[f"{key}.value"] = value edits[f"{key}.locked"] = 1 logger.info(f"Detail: {name} updated to {value}") else: logger.error( f"Metadata Error: {name} attribute is blank") add_edit("title", item.title, self.metadata[m], value=title) add_edit("sort_title", item.titleSort, self.metadata[m], key="titleSort") add_edit("originally_available", str(item.originallyAvailableAt)[:-9], self.metadata[m], key="originallyAvailableAt", value=originally_available) add_edit("rating", item.rating, self.metadata[m], value=rating) add_edit("content_rating", item.contentRating, self.metadata[m], key="contentRating") add_edit("original_title", item.originalTitle, self.metadata[m], key="originalTitle", value=original_title) add_edit("studio", item.studio, self.metadata[m], value=studio) add_edit("tagline", item.tagline, self.metadata[m], value=tagline) add_edit("summary", item.summary, self.metadata[m], value=summary) if len(edits) > 0: logger.debug(f"Details Update: {edits}") try: item.edit(**edits) item.reload() logger.info(f"{item_type}: {m} Details Update Successful") except BadRequest: util.print_stacktrace() logger.error(f"{item_type}: {m} Details Update Failed") else: logger.info(f"{item_type}: {m} Details Update Not Needed") genres = [] if tmdb_item: genres.extend([genre.name for genre in tmdb_item.genres]) if "genre" in self.metadata[m]: if self.metadata[m]["genre"]: genres.extend(util.get_list(self.metadata[m]["genre"])) else: logger.error("Metadata Error: genre attribute is blank") if len(genres) > 0: item_genres = [genre.tag for genre in item.genres] if "genre_sync_mode" in self.metadata[m]: if self.metadata[m]["genre_sync_mode"] is None: logger.error( "Metadata Error: genre_sync_mode attribute is blank defaulting to append" ) elif self.metadata[m]["genre_sync_mode"] not in [ "append", "sync" ]: logger.error( "Metadata Error: genre_sync_mode attribute must be either 'append' or 'sync' defaulting to append" ) elif self.metadata[m]["genre_sync_mode"] == "sync": for genre in (g for g in item_genres if g not in genres): item.removeGenre(genre) logger.info(f"Detail: Genre {genre} removed") for genre in (g for g in genres if g not in item_genres): item.addGenre(genre) logger.info(f"Detail: Genre {genre} added") if "label" in self.metadata[m]: if self.metadata[m]["label"]: item_labels = [label.tag for label in item.labels] labels = util.get_list(self.metadata[m]["label"]) if "label_sync_mode" in self.metadata[m]: if self.metadata[m]["label_sync_mode"] is None: logger.error( "Metadata Error: label_sync_mode attribute is blank defaulting to append" ) elif self.metadata[m]["label_sync_mode"] not in [ "append", "sync" ]: logger.error( "Metadata Error: label_sync_mode attribute must be either 'append' or 'sync' defaulting to append" ) elif self.metadata[m]["label_sync_mode"] == "sync": for label in (la for la in item_labels if la not in labels): item.removeLabel(label) logger.info(f"Detail: Label {label} removed") for label in (la for la in labels if la not in item_labels): item.addLabel(label) logger.info(f"Detail: Label {label} added") else: logger.error("Metadata Error: label attribute is blank") if "seasons" in self.metadata[m] and self.is_show: if self.metadata[m]["seasons"]: for season_id in self.metadata[m]["seasons"]: logger.info("") logger.info(f"Updating season {season_id} of {m}...") if isinstance(season_id, int): try: season = item.season(season_id) except NotFound: logger.error( f"Metadata Error: Season: {season_id} not found" ) else: if "title" in self.metadata[m]["seasons"][ season_id] and self.metadata[m][ "seasons"][season_id]["title"]: title = self.metadata[m]["seasons"][ season_id]["title"] else: title = season.title if "sub" in self.metadata[m]["seasons"][ season_id]: if self.metadata[m]["seasons"][season_id][ "sub"] is None: logger.error( "Metadata Error: sub attribute is blank" ) elif self.metadata[m]["seasons"][season_id][ "sub"] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif self.metadata[m]["seasons"][season_id][ "sub"] is False and title.endswith( " (SUB)"): title = title[:-6] else: logger.error( "Metadata Error: sub attribute must be True or False" ) edits = {} add_edit( "title", season.title, self.metadata[m]["seasons"][season_id], value=title) add_edit( "summary", season.summary, self.metadata[m]["seasons"][season_id]) if len(edits) > 0: logger.debug( f"Season: {season_id} Details Update: {edits}" ) try: season.edit(**edits) season.reload() logger.info( f"Season: {season_id} Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"Season: {season_id} Details Update Failed" ) else: logger.info( f"Season: {season_id} Details Update Not Needed" ) else: logger.error( f"Metadata Error: Season: {season_id} invalid, it must be an integer" ) else: logger.error("Metadata Error: seasons attribute is blank") if "episodes" in self.metadata[m] and self.is_show: if self.metadata[m]["episodes"]: for episode_str in self.metadata[m]["episodes"]: logger.info("") match = re.search("[Ss]\\d+[Ee]\\d+", episode_str) if match: output = match.group(0)[1:].split( "E" if "E" in m.group(0) else "e") episode_id = int(output[0]) season_id = int(output[1]) logger.info( f"Updating episode S{episode_id}E{season_id} of {m}..." ) try: episode = item.episode(season=season_id, episode=episode_id) except NotFound: logger.error( f"Metadata Error: episode {episode_id} of season {season_id} not found" ) else: if "title" in self.metadata[m]["episodes"][ episode_str] and self.metadata[m][ "episodes"][episode_str]["title"]: title = self.metadata[m]["episodes"][ episode_str]["title"] else: title = episode.title if "sub" in self.metadata[m]["episodes"][ episode_str]: if self.metadata[m]["episodes"][ episode_str]["sub"] is None: logger.error( "Metadata Error: sub attribute is blank" ) elif self.metadata[m]["episodes"][episode_str][ "sub"] is True and "(SUB)" not in title: title = f"{title} (SUB)" elif self.metadata[m]["episodes"][ episode_str][ "sub"] is False and title.endswith( " (SUB)"): title = title[:-6] else: logger.error( "Metadata Error: sub attribute must be True or False" ) edits = {} add_edit( "title", episode.title, self.metadata[m]["episodes"][episode_str], value=title) add_edit( "sort_title", episode.titleSort, self.metadata[m]["episodes"][episode_str], key="titleSort") add_edit( "rating", episode.rating, self.metadata[m]["episodes"][episode_str]) add_edit( "originally_available", str(episode.originallyAvailableAt)[:-9], self.metadata[m]["episodes"][episode_str], key="originallyAvailableAt") add_edit( "summary", episode.summary, self.metadata[m]["episodes"][episode_str]) if len(edits) > 0: logger.debug( f"Season: {season_id} Episode: {episode_id} Details Update: {edits}" ) try: episode.edit(**edits) episode.reload() logger.info( f"Season: {season_id} Episode: {episode_id} Details Update Successful" ) except BadRequest: util.print_stacktrace() logger.error( f"Season: {season_id} Episode: {episode_id} Details Update Failed" ) else: logger.info( f"Season: {season_id} Episode: {episode_id} Details Update Not Needed" ) else: logger.error( f"Metadata Error: episode {episode_str} invalid must have S##E## format" ) else: logger.error("Metadata Error: episodes attribute is blank")
def tvdb_tests(config): if config.TVDb: util.separator("TVDb Tests") tmdb_ids, tvdb_ids = config.TVDb.get_items( "tvdb_list", "https://www.thetvdb.com/lists/arrowverse", "en", status_message=False) if len(tvdb_ids) == 10 and len(tmdb_ids) == 0: logger.info("Success | TVDb URL get TVDb IDs and TMDb IDs") else: logger.error( f"Failure | TVDb URL get TVDb IDs and TMDb IDs: {len(tvdb_ids)} Should be 10 and {len(tmdb_ids)} Should be 0" ) tmdb_ids, tvdb_ids = config.TVDb.get_items( "tvdb_list", "https://www.thetvdb.com/lists/6957", "en", status_message=False) if len(tvdb_ids) == 4 and len(tmdb_ids) == 2: logger.info("Success | TVDb URL get TVDb IDs and TMDb IDs") else: logger.error( f"Failure | TVDb URL get TVDb IDs and TMDb IDs: {len(tvdb_ids)} Should be 4 and {len(tmdb_ids)} Should be 2" ) try: config.TVDb.get_items("tvdb_show", "https://www.thetvdb.com/series/arrow", "en", status_message=False) logger.info("Success | TVDb URL get TVDb Series ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | TVDb URL get TVDb Series ID: {e}") try: config.TVDb.get_items("tvdb_show", 279121, "en", status_message=False) logger.info("Success | TVDb ID get TVDb Series ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | TVDb ID get TVDb Series ID: {e}") try: config.TVDb.get_items( "tvdb_movie", "https://www.thetvdb.com/movies/the-lord-of-the-rings-the-fellowship-of-the-ring", "en", status_message=False) logger.info("Success | TVDb URL get TVDb Movie ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | TVDb URL get TVDb Movie ID: {e}") try: config.TVDb.get_items("tvdb_movie", 107, "en", status_message=False) logger.info("Success | TVDb ID get TVDb Movie ID") except Failed as e: util.print_stacktrace() logger.error(f"Failure | TVDb ID get TVDb Movie ID: {e}") else: util.separator("TVDb Not Configured")
def __init__(self, config, library, file_type, path): self.config = config self.library = library self.type = file_type self.path = path def get_dict(attribute, attr_data, check_list=None): if check_list is None: check_list = [] if attr_data and attribute in attr_data: if attr_data[attribute]: if isinstance(attr_data[attribute], dict): new_dict = {} for a_name, a_data in attr_data[attribute].items(): if a_name in check_list: logger.error( f"Config Warning: Skipping duplicate {attribute[:-1] if attribute[-1] == 's' else attribute}: {a_name}" ) else: new_dict[str(a_name)] = a_data return new_dict else: logger.warning( f"Config Warning: {attribute} must be a dictionary" ) else: logger.warning( f"Config Warning: {attribute} attribute is blank") return None if file_type == "Data": self.metadata = None self.collections = get_dict("collections", path, library.collections) self.templates = get_dict("templates", path) else: try: logger.info("") logger.info(f"Loading Metadata {file_type}: {path}") if file_type in ["URL", "Git"]: content_path = path if file_type == "URL" else f"{github_base}{path}.yml" response = self.config.get(content_path) if response.status_code >= 400: raise Failed( f"URL Error: No file found at {content_path}") content = response.content elif os.path.exists(os.path.abspath(path)): content = open(path, encoding="utf-8") else: raise Failed(f"File Error: File does not exist {path}") data, ind, bsi = yaml.util.load_yaml_guess_indent(content) self.metadata = get_dict("metadata", data, library.metadatas) self.templates = get_dict("templates", data) self.collections = get_dict("collections", data, library.collections) if self.metadata is None and self.collections is None: raise Failed( "YAML Error: metadata or collections attribute is required" ) logger.info(f"Metadata File Loaded Successfully") except yaml.scanner.ScannerError as ye: raise Failed(f"YAML Error: {util.tab_new_lines(ye)}") except Exception as e: util.print_stacktrace() raise Failed(f"YAML Error: {e}")