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 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 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 imdb_tests(config): if config.IMDb: util.separator("IMDb Tests") tmdb_ids, tvdb_ids = config.IMDb.get_items("imdb_list", { "url": "https://www.imdb.com/search/title/?groups=top_1000", "limit": 0 }, "en", status_message=False) if len(tmdb_ids) == 1000: logger.info("Success | IMDb URL get TMDb IDs") else: logger.error( f"Failure | IMDb URL get TMDb IDs: {len(tmdb_ids)} Should be 1000" ) tmdb_ids, tvdb_ids = config.IMDb.get_items("imdb_list", { "url": "https://www.imdb.com/list/ls026173135/", "limit": 0 }, "en", status_message=False) if len(tmdb_ids) == 250: logger.info("Success | IMDb URL get TMDb IDs") else: logger.error( f"Failure | IMDb URL get TMDb IDs: {len(tmdb_ids)} Should be 250" ) tmdb_ids, tvdb_ids = config.IMDb.get_items("imdb_id", "tt0814243", "en", status_message=False) if len(tmdb_ids) == 1: logger.info("Success | IMDb ID get TMDb IDs") else: logger.error( f"Failure | IMDb ID get TMDb IDs: {len(tmdb_ids)} Should be 1") else: util.separator("IMDb Not Configured")
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 run_tests(default_dir): try: config = Config(default_dir) logger.info("") util.separator("Mapping Tests") for library in config.libraries: config.map_guids(library) anidb_tests(config) imdb_tests(config) mal_tests(config) tautulli_tests(config) tmdb_tests(config) trakt_tests(config) tvdb_tests(config) util.separator("Finished All Plex Meta Manager Tests") except KeyboardInterrupt: util.separator("Canceled Plex Meta Manager Tests")
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 library_operations(config, library): logger.info("") util.separator(f"{library.name} Library Operations") logger.info("") logger.debug(f"Assets For All: {library.assets_for_all}") logger.debug(f"Delete Collections With Less: {library.delete_collections_with_less}") logger.debug(f"Delete Unmanaged Collections: {library.delete_unmanaged_collections}") logger.debug(f"Mass Genre Update: {library.mass_genre_update}") logger.debug(f"Mass Audience Rating Update: {library.mass_audience_rating_update}") logger.debug(f"Mass Critic Rating Update: {library.mass_critic_rating_update}") logger.debug(f"Mass Trakt Rating Update: {library.mass_trakt_rating_update}") logger.debug(f"Split Duplicates: {library.split_duplicates}") logger.debug(f"Radarr Add All: {library.radarr_add_all}") logger.debug(f"Sonarr Add All: {library.sonarr_add_all}") logger.debug(f"TMDb Collections: {library.tmdb_collections}") logger.debug(f"Genre Mapper: {library.genre_mapper}") tmdb_operation = library.assets_for_all or library.mass_genre_update or library.mass_audience_rating_update \ or library.mass_critic_rating_update or library.mass_trakt_rating_update \ or library.tmdb_collections or library.radarr_add_all or library.sonarr_add_all logger.debug(f"TMDb Operation: {tmdb_operation}") if library.split_duplicates: items = library.search(**{"duplicate": True}) for item in items: item.split() logger.info(util.adjust_space(f"{item.title[:25]:<25} | Splitting")) if tmdb_operation: items = library.get_all() radarr_adds = [] sonarr_adds = [] tmdb_collections = {} trakt_ratings = config.Trakt.user_ratings(library.is_movie) if library.mass_trakt_rating_update else [] for i, item in enumerate(items, 1): try: library.reload(item) except Failed as e: logger.error(e) continue util.print_return(f"Processing: {i}/{len(items)} {item.title}") if library.assets_for_all: library.update_item_from_assets(item, create=library.create_asset_folders) tmdb_id = None tvdb_id = None imdb_id = None if config.Cache: t_id, i_id, guid_media_type, _ = config.Cache.query_guid_map(item.guid) if t_id: if "movie" in guid_media_type: tmdb_id = t_id[0] else: tvdb_id = t_id[0] if i_id: imdb_id = i_id[0] if not tmdb_id and not tvdb_id: tmdb_id = library.get_tmdb_from_map(item) if not tmdb_id and not tvdb_id and library.is_show: tvdb_id = library.get_tvdb_from_map(item) if library.mass_trakt_rating_update: try: if library.is_movie and tmdb_id in trakt_ratings: new_rating = trakt_ratings[tmdb_id] elif library.is_show and tvdb_id in trakt_ratings: new_rating = trakt_ratings[tvdb_id] else: raise Failed if str(item.userRating) != str(new_rating): library.edit_query(item, {"userRating.value": new_rating, "userRating.locked": 1}) logger.info(util.adjust_space(f"{item.title[:25]:<25} | User Rating | {new_rating}")) except Failed: pass path = os.path.dirname(str(item.locations[0])) if library.is_movie else str(item.locations[0]) if library.Radarr and library.radarr_add_all and tmdb_id: path = path.replace(library.Radarr.plex_path, library.Radarr.radarr_path) path = path[:-1] if path.endswith(('/', '\\')) else path radarr_adds.append((tmdb_id, path)) if library.Sonarr and library.sonarr_add_all and tvdb_id: path = path.replace(library.Sonarr.plex_path, library.Sonarr.sonarr_path) path = path[:-1] if path.endswith(('/', '\\')) else path sonarr_adds.append((tvdb_id, path)) tmdb_item = None if library.tmdb_collections or library.mass_genre_update == "tmdb" or library.mass_audience_rating_update == "tmdb" or library.mass_critic_rating_update == "tmdb": if tvdb_id and not tmdb_id: tmdb_id = config.Convert.tvdb_to_tmdb(tvdb_id) if tmdb_id: try: tmdb_item = config.TMDb.get_movie(tmdb_id) if library.is_movie else config.TMDb.get_show(tmdb_id) except Failed as e: logger.error(util.adjust_space(str(e))) else: logger.info(util.adjust_space(f"{item.title[:25]:<25} | No TMDb ID for Guid: {item.guid}")) omdb_item = None if library.mass_genre_update in ["omdb", "imdb"] or library.mass_audience_rating_update in ["omdb", "imdb"] or library.mass_critic_rating_update in ["omdb", "imdb"]: if config.OMDb.limit is False: if tmdb_id and not imdb_id: imdb_id = config.Convert.tmdb_to_imdb(tmdb_id) elif tvdb_id and not imdb_id: imdb_id = config.Convert.tvdb_to_imdb(tvdb_id) if imdb_id: try: omdb_item = config.OMDb.get_omdb(imdb_id) except Failed as e: logger.error(util.adjust_space(str(e))) except Exception: logger.error(f"IMDb ID: {imdb_id}") raise else: logger.info(util.adjust_space(f"{item.title[:25]:<25} | No IMDb ID for Guid: {item.guid}")) tvdb_item = None if library.mass_genre_update == "tvdb": if tvdb_id: try: tvdb_item = config.TVDb.get_item(tvdb_id, library.is_movie) except Failed as e: logger.error(util.adjust_space(str(e))) else: logger.info(util.adjust_space(f"{item.title[:25]:<25} | No TVDb ID for Guid: {item.guid}")) if library.tmdb_collections and tmdb_item and tmdb_item.belongs_to_collection: tmdb_collections[tmdb_item.belongs_to_collection.id] = tmdb_item.belongs_to_collection.name if library.mass_genre_update: try: if tmdb_item and library.mass_genre_update == "tmdb": new_genres = [genre.name for genre in tmdb_item.genres] elif omdb_item and library.mass_genre_update in ["omdb", "imdb"]: new_genres = omdb_item.genres elif tvdb_item and library.mass_genre_update == "tvdb": new_genres = tvdb_item.genres else: raise Failed library.edit_tags("genre", item, sync_tags=new_genres) except Failed: pass if library.mass_audience_rating_update: try: if tmdb_item and library.mass_audience_rating_update == "tmdb": new_rating = tmdb_item.vote_average elif omdb_item and library.mass_audience_rating_update in ["omdb", "imdb"]: new_rating = omdb_item.imdb_rating else: raise Failed if new_rating is None: logger.info(util.adjust_space(f"{item.title[:25]:<25} | No Rating Found")) else: if library.mass_audience_rating_update and str(item.audienceRating) != str(new_rating): library.edit_query(item, {"audienceRating.value": new_rating, "audienceRating.locked": 1}) logger.info(util.adjust_space(f"{item.title[:25]:<25} | Audience Rating | {new_rating}")) except Failed: pass if library.mass_critic_rating_update: try: if tmdb_item and library.mass_critic_rating_update == "tmdb": new_rating = tmdb_item.vote_average elif omdb_item and library.mass_critic_rating_update in ["omdb", "imdb"]: new_rating = omdb_item.imdb_rating else: raise Failed if new_rating is None: logger.info(util.adjust_space(f"{item.title[:25]:<25} | No Rating Found")) else: if library.mass_critic_rating_update and str(item.rating) != str(new_rating): library.edit_query(item, {"rating.value": new_rating, "rating.locked": 1}) logger.info(util.adjust_space(f"{item.title[:25]:<25} | Critic Rating | {new_rating}")) except Failed: pass if library.genre_mapper: try: adds = [] deletes = [] library.reload(item) for genre in item.genres: if genre.tag in library.genre_mapper: deletes.append(genre.tag) adds.append(library.genre_mapper[genre.tag]) library.edit_tags("genre", item, add_tags=adds, remove_tags=deletes) except Failed: pass if library.Radarr and library.radarr_add_all: try: library.Radarr.add_tmdb(radarr_adds) except Failed as e: logger.error(e) if library.Sonarr and library.sonarr_add_all: try: library.Sonarr.add_tvdb(sonarr_adds) except Failed as e: logger.error(e) if tmdb_collections: logger.info("") util.separator(f"Starting TMDb Collections") logger.info("") metadata = Metadata(config, library, "Data", { "collections": { _n.replace(library.tmdb_collections["remove_suffix"], "").strip() if library.tmdb_collections["remove_suffix"] else _n: {"template": {"name": "TMDb Collection", "collection_id": _i}} for _i, _n in tmdb_collections.items() if int(_i) not in library.tmdb_collections["exclude_ids"] }, "templates": { "TMDb Collection": library.tmdb_collections["template"] } }) run_collection(config, library, metadata, metadata.get_collections(None)) if library.delete_collections_with_less is not None or library.delete_unmanaged_collections: logger.info("") suffix = "" unmanaged = "" if library.delete_collections_with_less is not None and library.delete_collections_with_less > 0: suffix = f" with less then {library.delete_collections_with_less} item{'s' if library.delete_collections_with_less > 1 else ''}" if library.delete_unmanaged_collections: if library.delete_collections_with_less is None: unmanaged = "Unmanaged Collections " elif library.delete_collections_with_less > 0: unmanaged = "Unmanaged Collections and " util.separator(f"Deleting All {unmanaged}Collections{suffix}", space=False, border=False) logger.info("") unmanaged_collections = [] for col in library.get_all_collections(): if (library.delete_collections_with_less is not None and (library.delete_collections_with_less == 0 or col.childCount < library.delete_collections_with_less)) \ or (col.title not in library.collections and library.delete_unmanaged_collections): library.query(col.delete) logger.info(f"{col.title} Deleted") elif col.title not in library.collections: unmanaged_collections.append(col) if library.show_unmanaged and len(unmanaged_collections) > 0: logger.info("") util.separator(f"Unmanaged Collections in {library.name} Library", space=False, border=False) logger.info("") for col in unmanaged_collections: logger.info(col.title) logger.info("") logger.info(f"{len(unmanaged_collections)} Unmanaged Collection{'s' if len(unmanaged_collections) > 1 else ''}") elif library.show_unmanaged: logger.info("") util.separator(f"No Unmanaged Collections in {library.name} Library", space=False, border=False) logger.info("") if library.assets_for_all and len(unmanaged_collections) > 0: logger.info("") util.separator(f"Unmanaged Collection Assets Check for {library.name} Library", space=False, border=False) logger.info("") for col in unmanaged_collections: poster, background = library.find_collection_assets(col, create=library.create_asset_folders) library.upload_images(col, poster=poster, background=background)
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 add_tmdb(self, tmdb_ids, **options): logger.info("") util.separator("Adding to Radarr", space=False, border=False) logger.debug("") _ids = [] _paths = [] for tmdb_id in tmdb_ids: if isinstance(tmdb_id, tuple): _paths.append(tmdb_id) else: _ids.append(tmdb_id) logger.debug(f"Radarr Adds: {_ids if _ids else ''}") for tmdb_id in _paths: logger.debug(tmdb_id) folder = options[ "folder"] if "folder" in options else self.root_folder_path monitor = options["monitor"] if "monitor" in options else self.monitor availability = availability_translation[ options["availability"] if "availability" in options else self.availability] quality_profile = options[ "quality"] if "quality" in options else self.quality_profile tags = options["tag"] if "tag" in options else self.tag search = options["search"] if "search" in options else self.search arr_paths = {} arr_ids = {} for movie in self.api.all_movies(): if movie.path: arr_paths[movie.path[:-1] if movie.path.endswith( ("/", "\\")) else movie.path] = movie.tmdbId arr_ids[movie.tmdbId] = movie logger.debug(arr_paths) logger.debug(arr_ids) added = [] exists = [] skipped = [] invalid = [] movies = [] path_lookup = {} mismatched = {} path_in_use = {} for i, item in enumerate(tmdb_ids, 1): path = item[1] if isinstance(item, tuple) else None tmdb_id = item[0] if isinstance(item, tuple) else item util.print_return( f"Loading TMDb ID {i}/{len(tmdb_ids)} ({tmdb_id})") if self.config.Cache: _id = self.config.Cache.query_radarr_adds( tmdb_id, self.library.original_mapping_name) if _id: skipped.append(item) continue try: if tmdb_id in arr_ids: exists.append(arr_ids[tmdb_id]) continue if path in arr_paths: mismatched[path] = tmdb_id continue movie = self.api.get_movie(tmdb_id=tmdb_id) if f"{folder}/{movie.folder}" in arr_paths: path_in_use[f"{folder}/{movie.folder}"] = tmdb_id continue if path: movies.append((movie, path)) path_lookup[path] = tmdb_id else: movies.append(movie) except ArrException: invalid.append(item) if len(movies) == 100 or len(tmdb_ids) == i: try: _a, _e, _i = self.api.add_multiple_movies(movies, folder, quality_profile, monitor, search, availability, tags, per_request=100) added.extend(_a) exists.extend(_e) invalid.extend(_i) movies = [] except Invalid as e: raise Failed(f"Radarr Error: {e}") if len(added) > 0: logger.info("") for movie in added: logger.info( f"Added to Radarr | {movie.tmdbId:<6} | {movie.title}") if self.config.Cache: self.config.Cache.update_radarr_adds( movie.tmdbId, self.library.original_mapping_name) logger.info( f"{len(added)} Movie{'s' if len(added) > 1 else ''} added to Radarr" ) if len(exists) > 0 or len(skipped) > 0: logger.info("") if len(exists) > 0: for movie in exists: logger.info( f"Already in Radarr | {movie.tmdbId:<6} | {movie.title}" ) if self.config.Cache: self.config.Cache.update_radarr_adds( movie.tmdbId, self.library.original_mapping_name) if len(skipped) > 0: for movie in skipped: logger.info(f"Skipped: In Cache | {movie}") logger.info( f"{len(exists) + len(skipped)} Movie{'s' if len(skipped) > 1 else ''} already exist in Radarr" ) if len(mismatched) > 0: logger.info("") logger.info( "Items in Plex that have already been added to Radarr but under a different TMDb ID then in Plex" ) for path, tmdb_id in mismatched.items(): logger.info( f"Plex TMDb ID: {tmdb_id:<7} | Radarr TMDb ID: {arr_paths[path]:<7} | Path: {path}" ) logger.info( f"{len(mismatched)} Movie{'s' if len(mismatched) > 1 else ''} with mismatched TMDb IDs" ) if len(path_in_use) > 0: logger.info("") logger.info( "TMDb IDs that cannot be added to Radarr because the path they will use is already in use by a different TMDb ID" ) for path, tmdb_id in path_in_use.items(): logger.info( f"TMDb ID: {tmdb_id:<7} | Radarr TMDb ID: {arr_paths[path]:<7} | Path: {path}" ) logger.info( f"{len(path_in_use)} Movie{'s' if len(path_in_use) > 1 else ''} with paths already in use by other TMDb IDs" ) if len(invalid) > 0: logger.info("") for tmdb_id in invalid: logger.info(f"Invalid TMDb ID | {tmdb_id}") logger.info( f"{len(invalid)} Movie{'s' if len(invalid) > 1 else ''} with Invalid IDs" ) return len(added)
encoding="utf-8") file_handler.addFilter(fmt_filter) file_handler.setFormatter( logging.Formatter( "[%(asctime)s] %(filename)-27s %(levelname)-10s | %(message)-100s |")) cmd_handler = logging.StreamHandler() cmd_handler.setFormatter(logging.Formatter("| %(message)-100s |")) cmd_handler.setLevel(logging.DEBUG if tests or test or debug else logging.INFO) logger.addHandler(cmd_handler) logger.addHandler(file_handler) sys.excepthook = util.my_except_hook util.separator() logger.info( util.get_centered_text( " " )) logger.info( util.get_centered_text( " ____ _ __ __ _ __ __ " )) logger.info( util.get_centered_text( "| _ \\| | _____ __ | \\/ | ___| |_ __ _ | \\/ | __ _ _ __ __ _ __ _ ___ _ __ " )) logger.info( util.get_centered_text( "| |_) | |/ _ \\ \\/ / | |\\/| |/ _ \\ __/ _` | | |\\/| |/ _` | '_ \\ / _` |/ _` |/ _ \\ '__|"
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_libraries(config): global stats for library in config.libraries: try: os.makedirs(os.path.join(default_dir, "logs", library.mapping_name, "collections"), exist_ok=True) col_file_logger = os.path.join(default_dir, "logs", library.mapping_name, "library.log") should_roll_over = os.path.isfile(col_file_logger) library_handler = RotatingFileHandler(col_file_logger, delay=True, mode="w", backupCount=3, encoding="utf-8") util.apply_formatter(library_handler) if should_roll_over: library_handler.doRollover() logger.addHandler(library_handler) plexapi.server.TIMEOUT = library.timeout logger.info("") util.separator(f"{library.name} Library") logger.debug("") logger.debug(f"Mapping Name: {library.original_mapping_name}") logger.debug(f"Folder Name: {library.mapping_name}") logger.debug(f"Missing Path: {library.missing_path}") for ad in library.asset_directory: logger.debug(f"Asset Directory: {ad}") logger.debug(f"Asset Folders: {library.asset_folders}") logger.debug(f"Create Asset Folders: {library.create_asset_folders}") logger.debug(f"Sync Mode: {library.sync_mode}") logger.debug(f"Collection Minimum: {library.collection_minimum}") logger.debug(f"Delete Below Minimum: {library.delete_below_minimum}") logger.debug(f"Delete Not Scheduled: {library.delete_not_scheduled}") logger.debug(f"Missing Only Released: {library.missing_only_released}") logger.debug(f"Only Filter Missing: {library.only_filter_missing}") logger.debug(f"Show Unmanaged: {library.show_unmanaged}") logger.debug(f"Show Filtered: {library.show_filtered}") logger.debug(f"Show Missing: {library.show_missing}") logger.debug(f"Show Missing Assets: {library.show_missing_assets}") logger.debug(f"Save Missing: {library.save_missing}") logger.debug(f"Assets For All: {library.assets_for_all}") logger.debug(f"Delete Collections With Less: {library.delete_collections_with_less}") logger.debug(f"Delete Unmanaged Collections: {library.delete_unmanaged_collections}") logger.debug(f"Mass Genre Update: {library.mass_genre_update}") logger.debug(f"Mass Audience Rating Update: {library.mass_audience_rating_update}") logger.debug(f"Mass Critic Rating Update: {library.mass_critic_rating_update}") logger.debug(f"Mass Trakt Rating Update: {library.mass_trakt_rating_update}") logger.debug(f"Split Duplicates: {library.split_duplicates}") logger.debug(f"Radarr Add All: {library.radarr_add_all}") logger.debug(f"Sonarr Add All: {library.sonarr_add_all}") logger.debug(f"TMDb Collections: {library.tmdb_collections}") logger.debug(f"Genre Mapper: {library.genre_mapper}") logger.debug(f"Clean Bundles: {library.clean_bundles}") logger.debug(f"Empty Trash: {library.empty_trash}") logger.debug(f"Optimize: {library.optimize}") logger.debug(f"Timeout: {library.timeout}") if not library.is_other: logger.info("") util.separator(f"Mapping {library.name} Library", space=False, border=False) logger.info("") library.map_guids() for metadata in library.metadata_files: logger.info("") util.separator(f"Running Metadata File\n{metadata.path}") if not config.test_mode and not config.resume_from and not collection_only: try: metadata.update_metadata() except Failed as e: library.notify(e) logger.error(e) collections_to_run = metadata.get_collections(config.requested_collections) if config.resume_from and config.resume_from not in collections_to_run: logger.info("") logger.warning(f"Collection: {config.resume_from} not in Metadata File: {metadata.path}") continue if collections_to_run and not library_only: logger.info("") util.separator(f"{'Test ' if config.test_mode else ''}Collections") logger.removeHandler(library_handler) run_collection(config, library, metadata, collections_to_run) logger.addHandler(library_handler) if library.run_sort: logger.info("") util.separator(f"Sorting {library.name} Library's Collections", space=False, border=False) logger.info("") for builder in library.run_sort: logger.info("") util.separator(f"Sorting {builder.name} Collection", space=False, border=False) logger.info("") builder.sort_collection() if not config.test_mode and not collection_only: library_operations(config, library) logger.removeHandler(library_handler) except Exception as e: library.notify(e) util.print_stacktrace() util.print_multiline(e, critical=True) has_run_again = False for library in config.libraries: if library.run_again: has_run_again = True break if has_run_again and not library_only: logger.info("") util.separator("Run Again") logger.info("") for x in range(1, config.general["run_again_delay"] + 1): util.print_return(f"Waiting to run again in {config.general['run_again_delay'] - x + 1} minutes") for y in range(60): time.sleep(1) util.print_end() for library in config.libraries: if library.run_again: try: col_file_logger = os.path.join(default_dir, "logs", library.mapping_name, f"library.log") library_handler = RotatingFileHandler(col_file_logger, mode="w", backupCount=3, encoding="utf-8") util.apply_formatter(library_handler) logger.addHandler(library_handler) library_handler.addFilter(fmt_filter) os.environ["PLEXAPI_PLEXAPI_TIMEOUT"] = str(library.timeout) logger.info("") util.separator(f"{library.name} Library Run Again") logger.info("") library.map_guids() for builder in library.run_again: logger.info("") util.separator(f"{builder.name} Collection") logger.info("") try: builder.run_collections_again() except Failed as e: library.notify(e, collection=builder.name, critical=False) util.print_stacktrace() util.print_multiline(e, error=True) logger.removeHandler(library_handler) except Exception as e: library.notify(e) util.print_stacktrace() util.print_multiline(e, critical=True) used_url = [] for library in config.libraries: if library.url not in used_url: used_url.append(library.url) if library.empty_trash: library.query(library.PlexServer.library.emptyTrash) if library.clean_bundles: library.query(library.PlexServer.library.cleanBundles) if library.optimize: library.query(library.PlexServer.library.optimize)
def update_metadata(self): if not self.metadata: return None logger.info("") util.separator("Running Metadata") logger.info("") for mapping_name, meta in self.metadata.items(): methods = {mm.lower(): mm for mm in meta} if self.config.test_mode and ("test" not in methods or meta[methods["test"]] is not True): continue updated = False edits = {} advance_edits = {} def add_edit(name, current_item, 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: current = str(getattr(current_item, key, "")) if var_type == "date": final_value = util.validate_date( value, name, return_as="%Y-%m-%d") current = current[:-9] elif var_type == "float": final_value = util.parse(name, value, datatype="float", minimum=0, maximum=10) else: final_value = value if 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") def add_advanced_edit(attr, obj, group, alias, show_library=False, new_agent=False): key, options = plex.item_advance_keys[f"item_{attr}"] if attr in alias: if new_agent and self.library.agent not in plex.new_plex_agents: logger.error( f"Metadata Error: {attr} attribute only works for with the New Plex Movie Agent and New Plex TV Agent" ) elif show_library and not self.library.is_show: logger.error( f"Metadata Error: {attr} attribute only works for show libraries" ) elif group[alias[attr]]: method_data = str(group[alias[attr]]).lower() if method_data not in options: logger.error( f"Metadata Error: {group[alias[attr]]} {attr} attribute invalid" ) elif getattr(obj, 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: {attr} attribute is blank") def edit_tags(attr, obj, group, alias, extra=None, movie_library=False): if movie_library and not self.library.is_movie and ( attr in alias or f"{attr}.sync" in alias or f"{attr}.remove" in alias): logger.error( f"Metadata Error: {attr} attribute only works for movie libraries" ) elif attr in alias and f"{attr}.sync" in alias: logger.error( f"Metadata Error: Cannot use {attr} and {attr}.sync together" ) elif f"{attr}.remove" in alias and f"{attr}.sync" in alias: logger.error( f"Metadata Error: Cannot use {attr}.remove and {attr}.sync together" ) elif attr in alias and group[alias[attr]] is None: logger.error(f"Metadata Error: {attr} attribute is blank") elif f"{attr}.remove" in alias and group[ alias[f"{attr}.remove"]] is None: logger.error( f"Metadata Error: {attr}.remove attribute is blank") elif f"{attr}.sync" in alias and group[ alias[f"{attr}.sync"]] is None: logger.error( f"Metadata Error: {attr}.sync attribute is blank") elif attr in alias or f"{attr}.remove" in alias or f"{attr}.sync" in alias: add_tags = util.get_list( group[alias[attr]]) if attr in alias else [] if extra: add_tags.extend(extra) remove_tags = util.get_list( group[alias[f"{attr}.remove"]] ) if f"{attr}.remove" in alias else None sync_tags = util.get_list( group[alias[f"{attr}.sync"]] if group[alias[f"{attr}.sync"]] else [] ) if f"{attr}.sync" in alias else None return self.library.edit_tags(attr, obj, add_tags=add_tags, remove_tags=remove_tags, sync_tags=sync_tags) return False def set_image(attr, group, alias, is_poster=True, is_url=True): if group[alias[attr]]: return ImageData(attr, group[alias[attr]], is_poster=is_poster, is_url=is_url) else: logger.error(f"Metadata Error: {attr} attribute is blank") def set_images(obj, group, alias): poster = None background = None if "url_poster" in alias: poster = set_image("url_poster", group, alias) elif "file_poster" in alias: poster = set_image("file_poster", group, alias, is_url=False) if "url_background" in alias: background = set_image("url_background", group, alias, is_poster=False) elif "file_background" in alias: background = set_image("file_background", group, alias, is_poster=False, is_url=False) if poster or background: self.library.upload_images(obj, poster=poster, background=background) logger.info("") util.separator() logger.info("") year = None if "year" in methods: year = util.parse("year", meta, datatype="int", methods=methods, 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.library.search_item(title, year=year) if item is None: item = self.library.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.library.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.library.is_movie else "Show" logger.info(f"Updating {item_type}: {title}...") tmdb_item = None tmdb_is_movie = None if ("tmdb_show" in methods or "tmdb_id" in methods) and "tmdb_movie" in methods: logger.error( "Metadata Error: Cannot use tmdb_movie and tmdb_show when editing the same metadata item" ) if "tmdb_show" in methods or "tmdb_id" in methods or "tmdb_movie" in methods: try: if "tmdb_show" in methods or "tmdb_id" in methods: data = meta[methods["tmdb_show" if "tmdb_show" in methods else "tmdb_id"]] if data is None: logger.error( "Metadata Error: tmdb_show attribute is blank") else: tmdb_is_movie = False tmdb_item = self.config.TMDb.get_show( util.regex_first_int(data, "Show")) elif "tmdb_movie" in methods: if meta[methods["tmdb_movie"]] is None: logger.error( "Metadata Error: tmdb_movie attribute is blank" ) else: tmdb_is_movie = True tmdb_item = self.config.TMDb.get_movie( util.regex_first_int( meta[methods["tmdb_movie"]], "Movie")) except Failed as e: logger.error(e) originally_available = None original_title = None rating = None studio = None tagline = None summary = None genres = [] if tmdb_item: originally_available = tmdb_item.release_date if tmdb_is_movie else tmdb_item.first_air_date if tmdb_item and tmdb_is_movie is True and tmdb_item.original_title != tmdb_item.title: original_title = tmdb_item.original_title elif tmdb_item and tmdb_is_movie is False and tmdb_item.original_name != tmdb_item.name: original_title = tmdb_item.original_name rating = tmdb_item.vote_average if tmdb_is_movie is True and tmdb_item.production_companies: studio = tmdb_item.production_companies[0].name elif tmdb_is_movie is False and tmdb_item.networks: studio = tmdb_item.networks[0].name tagline = tmdb_item.tagline if len( tmdb_item.tagline) > 0 else None summary = tmdb_item.overview genres = [genre.name for genre in tmdb_item.genres] edits = {} add_edit("title", item, meta, methods, value=title) add_edit("sort_title", item, meta, methods, key="titleSort") add_edit("originally_available", item, meta, methods, key="originallyAvailableAt", value=originally_available, var_type="date") add_edit("critic_rating", item, meta, methods, value=rating, key="rating", var_type="float") add_edit("audience_rating", item, meta, methods, key="audienceRating", var_type="float") add_edit("user_rating", item, meta, methods, key="userRating", var_type="float") add_edit("content_rating", item, meta, methods, key="contentRating") add_edit("original_title", item, meta, methods, key="originalTitle", value=original_title) add_edit("studio", item, meta, methods, value=studio) add_edit("tagline", item, meta, methods, value=tagline) add_edit("summary", item, meta, methods, value=summary) if self.library.edit_item(item, mapping_name, item_type, edits): updated = True advance_edits = {} for advance_edit in [ "episode_sorting", "keep_episodes", "delete_episodes", "season_display", "episode_ordering", "metadata_language", "use_original_title" ]: is_show = advance_edit in [ "episode_sorting", "keep_episodes", "delete_episodes", "season_display", "episode_ordering" ] is_new_agent = advance_edit in [ "metadata_language", "use_original_title" ] add_advanced_edit(advance_edit, item, meta, methods, show_library=is_show, new_agent=is_new_agent) if self.library.edit_item(item, mapping_name, item_type, advance_edits, advanced=True): updated = True for tag_edit in [ "genre", "label", "collection", "country", "director", "producer", "writer" ]: is_movie = tag_edit in [ "country", "director", "producer", "writer" ] has_extra = genres if tag_edit == "genre" else None if edit_tags(tag_edit, item, meta, methods, movie_library=is_movie, extra=has_extra): updated = True logger.info( f"{item_type}: {mapping_name} Details Update {'Complete' if updated else 'Not Needed'}" ) set_images(item, meta, methods) if "seasons" in methods and self.library.is_show: if meta[methods["seasons"]]: for season_id in meta[methods["seasons"]]: updated = False logger.info("") logger.info( f"Updating season {season_id} of {mapping_name}..." ) if isinstance(season_id, int): season = None for s in item.seasons(): if s.index == season_id: season = s break if season is None: 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, season_dict, season_methods, value=title) add_edit("summary", season, season_dict, season_methods) if self.library.edit_item( season, season_id, "Season", edits): updated = True set_images(season, season_dict, season_methods) else: logger.error( f"Metadata Error: Season: {season_id} invalid, it must be an integer" ) logger.info( f"Season {season_id} of {mapping_name} Details Update {'Complete' if updated else 'Not Needed'}" ) 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.library.is_show: if meta[methods["episodes"]]: for episode_str in meta[methods["episodes"]]: updated = False 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{season_id}E{episode_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, episode_dict, episode_methods, value=title) add_edit("sort_title", episode, episode_dict, episode_methods, key="titleSort") add_edit("rating", episode, episode_dict, episode_methods, var_type="float") add_edit("originally_available", episode, episode_dict, episode_methods, key="originallyAvailableAt", var_type="date") add_edit("summary", episode, episode_dict, episode_methods) if self.library.edit_item( episode, f"{season_id} Episode: {episode_id}", "Season", edits): updated = True if edit_tags("director", episode, episode_dict, episode_methods): updated = True if edit_tags("writer", episode, episode_dict, episode_methods): updated = True set_images(episode, episode_dict, episode_methods) logger.info( f"Episode S{season_id}E{episode_id} of {mapping_name} Details Update {'Complete' if updated else '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") elif "episodes" in methods: logger.error( "Metadata Error: episodes attribute only works for show libraries" )
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 updated = False edits = {} advance_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") def add_advanced_edit(attr, obj, group, alias, show_library=False, new_agent=False): key, options = advance_keys[attr] if attr in alias: if new_agent and self.agent not in new_plex_agents: logger.error(f"Metadata Error: {attr} attribute only works for with the New Plex Movie Agent and New Plex TV Agent") elif show_library and not self.is_show: logger.error(f"Metadata Error: {attr} attribute only works for show libraries") elif group[alias[attr]]: method_data = str(group[alias[attr]]).lower() if method_data not in options: logger.error(f"Metadata Error: {group[alias[attr]]} {attr} attribute invalid") elif getattr(obj, 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: {attr} attribute is blank") def edit_tags(attr, obj, group, alias, key=None, extra=None, movie_library=False): if key is None: key = f"{attr}s" if attr in alias and f"{attr}.sync" in alias: logger.error(f"Metadata Error: Cannot use {attr} and {attr}.sync together") elif attr in alias or f"{attr}.sync" in alias: attr_key = attr if attr in alias 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 group[alias[attr_key]] or extra: item_tags = [item_tag.tag for item_tag in getattr(obj, key)] input_tags = [] if group[alias[attr_key]]: input_tags.extend(util.get_list(group[alias[attr_key]])) if extra: input_tags.extend(extra) if f"{attr}.sync" in alias: 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") def set_image(attr, obj, group, alias, is_background=False): if group[alias[attr]]: message = f"{'background' if is_background else 'poster'} to [{'File' if attr.startswith('file') else 'URL'}] {group[alias[attr]]}" if group[alias[attr]] and attr.startswith("url") and is_background: obj.uploadArt(url=group[alias[attr]]) elif group[alias[attr]] and attr.startswith("url"): obj.uploadPoster(url=group[alias[attr]]) elif group[alias[attr]] and attr.startswith("file") and is_background: obj.uploadArt(filepath=group[alias[attr]]) elif group[alias[attr]] and attr.startswith("file"): obj.uploadPoster(filepath=group[alias[attr]]) logger.info(f"Detail: {attr} updated {message}") else: logger.error(f"Metadata Error: {attr} attribute is blank") def set_images(obj, group, alias): if "url_poster" in alias: set_image("url_poster", obj, group, alias) elif "file_poster" in alias: set_image("file_poster", obj, group, alias) if "url_background" in alias: set_image("url_background", obj, group, alias, is_background=True) elif "file_background" in alias: set_image("file_background", obj, group, alias, is_background=True) 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 tmdb_is_movie = None if ("tmdb_show" in methods or "tmdb_id" in methods) and "tmdb_movie" in methods: logger.error("Metadata Error: Cannot use tmdb_movie and tmdb_show when editing the same metadata item") if "tmdb_show" in methods or "tmdb_id" in methods or "tmdb_movie" in methods: try: if "tmdb_show" in methods or "tmdb_id" in methods: data = meta[methods["tmdb_show" if "tmdb_show" in methods else "tmdb_id"]] if data is None: logger.error("Metadata Error: tmdb_show attribute is blank") else: tmdb_is_movie = False tmdb_item = TMDb.get_show(util.regex_first_int(data, "Show")) elif "tmdb_movie" in methods: if meta[methods["tmdb_movie"]] is None: logger.error("Metadata Error: tmdb_movie attribute is blank") else: tmdb_is_movie = True tmdb_item = TMDb.get_movie(util.regex_first_int(meta[methods["tmdb_movie"]], "Movie")) except Failed as e: logger.error(e) originally_available = None original_title = None rating = None studio = None tagline = None summary = None genres = [] if tmdb_item: originally_available = tmdb_item.release_date if tmdb_is_movie else tmdb_item.first_air_date if tmdb_item and tmdb_is_movie is True and tmdb_item.original_title != tmdb_item.title: original_title = tmdb_item.original_title elif tmdb_item and tmdb_is_movie is False and tmdb_item.original_name != tmdb_item.name: original_title = tmdb_item.original_name rating = tmdb_item.vote_average if tmdb_is_movie is True and tmdb_item.production_companies: studio = tmdb_item.production_companies[0].name elif tmdb_is_movie is False and tmdb_item.networks: studio = tmdb_item.networks[0].name tagline = tmdb_item.tagline if len(tmdb_item.tagline) > 0 else None summary = tmdb_item.overview genres = [genre.name for genre in tmdb_item.genres] edits = {} 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) self.edit_item(item, mapping_name, item_type, edits) advance_edits = {} add_advanced_edit("episode_sorting", item, meta, methods, show_library=True) add_advanced_edit("keep_episodes", item, meta, methods, show_library=True) add_advanced_edit("delete_episodes", item, meta, methods, show_library=True) add_advanced_edit("season_display", item, meta, methods, show_library=True) add_advanced_edit("episode_ordering", item, meta, methods, show_library=True) add_advanced_edit("metadata_language", item, meta, methods, new_agent=True) add_advanced_edit("use_original_title", item, meta, methods, new_agent=True) self.edit_item(item, mapping_name, item_type, advance_edits, advanced=True) edit_tags("genre", item, meta, methods, extra=genres) edit_tags("label", item, meta, methods) edit_tags("collection", item, meta, methods) edit_tags("country", item, meta, methods, key="countries", movie_library=True) edit_tags("director", item, meta, methods, movie_library=True) edit_tags("producer", item, meta, methods, movie_library=True) edit_tags("writer", item, meta, methods, movie_library=True) logger.info(f"{item_type}: {mapping_name} Details Update {'Complete' if updated else 'Not Needed'}") set_images(item, meta, methods) if "seasons" in methods and self.is_show: if meta[methods["seasons"]]: for season_id in meta[methods["seasons"]]: updated = False logger.info("") logger.info(f"Updating season {season_id} of {mapping_name}...") if isinstance(season_id, int): season = None for s in item.seasons(): if s.index == season_id: season = s break if season is None: 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_dict, season_methods) self.edit_item(season, season_id, "Season", edits) set_images(season, season_dict, season_methods) else: logger.error(f"Metadata Error: Season: {season_id} invalid, it must be an integer") logger.info(f"Season {season_id} of {mapping_name} Details Update {'Complete' if updated else 'Not Needed'}") 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"]]: updated = False 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{season_id}E{episode_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) self.edit_item(episode, f"{season_id} Episode: {episode_id}", "Season", edits) edit_tags("director", episode, episode_dict, episode_methods) edit_tags("writer", episode, episode_dict, episode_methods) set_images(episode, episode_dict, episode_methods) logger.info(f"Episode S{episode_id}E{season_id} of {mapping_name} Details Update {'Complete' if updated else '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") elif "episodes" in methods: logger.error("Metadata Error: episodes attribute only works for show libraries")
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 run_collection(config, library, metadata, requested_collections): global stats logger.info("") for mapping_name, collection_attrs in requested_collections.items(): collection_start = datetime.now() if config.test_mode and ("test" not in collection_attrs or collection_attrs["test"] is not True): no_template_test = True if "template" in collection_attrs and collection_attrs["template"]: for data_template in util.get_list(collection_attrs["template"], split=False): if "name" in data_template \ and data_template["name"] \ and metadata.templates \ and data_template["name"] in metadata.templates \ and metadata.templates[data_template["name"]] \ and "test" in metadata.templates[data_template["name"]] \ and metadata.templates[data_template["name"]]["test"] is True: no_template_test = False if no_template_test: continue if config.resume_from and config.resume_from != mapping_name: continue elif config.resume_from == mapping_name: config.resume_from = None logger.info("") util.separator(f"Resuming Collections") if "name_mapping" in collection_attrs and collection_attrs["name_mapping"]: collection_log_name, output_str = util.validate_filename(collection_attrs["name_mapping"]) else: collection_log_name, output_str = util.validate_filename(mapping_name) collection_log_folder = os.path.join(default_dir, "logs", library.mapping_name, "collections", collection_log_name) os.makedirs(collection_log_folder, exist_ok=True) col_file_logger = os.path.join(collection_log_folder, "collection.log") should_roll_over = os.path.isfile(col_file_logger) collection_handler = RotatingFileHandler(col_file_logger, delay=True, mode="w", backupCount=3, encoding="utf-8") util.apply_formatter(collection_handler) if should_roll_over: collection_handler.doRollover() logger.addHandler(collection_handler) try: util.separator(f"{mapping_name} Collection") logger.info("") if output_str: logger.info(output_str) logger.info("") util.separator(f"Validating {mapping_name} Attributes", space=False, border=False) builder = CollectionBuilder(config, library, metadata, mapping_name, no_missing, collection_attrs) logger.info("") util.separator(f"Running {mapping_name} Collection", space=False, border=False) if len(builder.schedule) > 0: util.print_multiline(builder.schedule, info=True) if len(builder.smart_filter_details) > 0: logger.info("") util.print_multiline(builder.smart_filter_details, info=True) items_added = 0 items_removed = 0 if not builder.smart_url and builder.builders: logger.info("") logger.info(f"Sync Mode: {'sync' if builder.sync else 'append'}") if builder.filters or builder.tmdb_filters: logger.info("") for filter_key, filter_value in builder.filters: logger.info(f"Collection Filter {filter_key}: {filter_value}") for filter_key, filter_value in builder.tmdb_filters: logger.info(f"Collection Filter {filter_key}: {filter_value}") builder.find_rating_keys() if len(builder.rating_keys) >= builder.minimum and builder.build_collection: logger.info("") util.separator(f"Adding to {mapping_name} Collection", space=False, border=False) logger.info("") items_added = builder.add_to_collection() stats["added"] += items_added items_removed = 0 if builder.sync: items_removed = builder.sync_collection() stats["removed"] += items_removed elif len(builder.rating_keys) < builder.minimum and builder.build_collection: logger.info("") logger.info(f"Collection Minimum: {builder.minimum} not met for {mapping_name} Collection") if builder.details["delete_below_minimum"] and builder.obj: builder.delete_collection() builder.deleted = True logger.info("") logger.info(f"Collection {builder.obj.title} deleted") if builder.do_missing and (len(builder.missing_movies) > 0 or len(builder.missing_shows) > 0): if builder.details["show_missing"] is True: logger.info("") util.separator(f"Missing from Library", space=False, border=False) logger.info("") radarr_add, sonarr_add = builder.run_missing() stats["radarr"] += radarr_add stats["sonarr"] += sonarr_add run_item_details = True if builder.build_collection and builder.builders: try: builder.load_collection() if builder.created: stats["created"] += 1 elif items_added > 0 or items_removed > 0: stats["modified"] += 1 except Failed: util.print_stacktrace() run_item_details = False logger.info("") util.separator("No Collection to Update", space=False, border=False) else: builder.update_details() if builder.custom_sort: library.run_sort.append(builder) # builder.sort_collection() if builder.deleted: stats["deleted"] += 1 if builder.server_preroll is not None: library.set_server_preroll(builder.server_preroll) logger.info("") logger.info(f"Plex Server Movie pre-roll video updated to {builder.server_preroll}") builder.send_notifications() if builder.item_details and run_item_details and builder.builders: try: builder.load_collection_items() except Failed: logger.info("") util.separator("No Items Found", space=False, border=False) else: builder.update_item_details() if builder.run_again and (len(builder.run_again_movies) > 0 or len(builder.run_again_shows) > 0): library.run_again.append(builder) except NotScheduled as e: util.print_multiline(e, info=True) except Failed as e: library.notify(e, collection=mapping_name) util.print_stacktrace() util.print_multiline(e, error=True) except Exception as e: library.notify(f"Unknown Error: {e}", collection=mapping_name) util.print_stacktrace() logger.error(f"Unknown Error: {e}") logger.info("") util.separator(f"Finished {mapping_name} Collection\nCollection Run Time: {str(datetime.now() - collection_start).split('.')[0]}") logger.removeHandler(collection_handler)
def add_tvdb(self, tvdb_ids, **options): logger.info("") util.separator("Adding to Sonarr", space=False, border=False) logger.debug("") _ids = [] _paths = [] for tvdb_id in tvdb_ids: if isinstance(tvdb_id, tuple): _paths.append(tvdb_id) else: _ids.append(tvdb_id) logger.debug(f"Radarr Adds: {_ids if _ids else ''}") for tvdb_id in _paths: logger.debug(tvdb_id) folder = options[ "folder"] if "folder" in options else self.root_folder_path monitor = monitor_translation[options["monitor"] if "monitor" in options else self.monitor] quality_profile = options[ "quality"] if "quality" in options else self.quality_profile language_profile = options[ "language"] if "language" in options else self.language_profile language_profile = language_profile if self.api._raw.v3 else 1 series = options["series"] if "series" in options else self.series_type season = options[ "season"] if "season" in options else self.season_folder tags = options["tag"] if "tag" in options else self.tag search = options["search"] if "search" in options else self.search cutoff_search = options[ "cutoff_search"] if "cutoff_search" in options else self.cutoff_search arr_paths = {} arr_ids = {} for series in self.api.all_series(): if series.path: arr_paths[series.path[:-1] if series.path.endswith( ("/", "\\")) else series.path] = series.tvdbId arr_paths[series.tvdbId] = series logger.debug(arr_paths) logger.debug(arr_ids) added = [] exists = [] skipped = [] invalid = [] shows = [] path_lookup = {} mismatched = {} path_in_use = {} for i, item in enumerate(tvdb_ids, 1): path = item[1] if isinstance(item, tuple) else None tvdb_id = item[0] if isinstance(item, tuple) else item util.print_return( f"Loading TVDb ID {i}/{len(tvdb_ids)} ({tvdb_id})") if self.config.Cache: _id = self.config.Cache.query_sonarr_adds( tvdb_id, self.library.original_mapping_name) if _id: skipped.append(item) continue try: if tvdb_id in arr_ids: exists.append(arr_ids[tvdb_id]) continue if path in arr_paths: mismatched[path] = tvdb_id continue show = self.api.get_series(tvdb_id=tvdb_id) if f"{folder}/{show.folder}" in arr_paths: path_in_use[f"{folder}/{show.folder}"] = tvdb_id continue if path: shows.append((show, path)) path_lookup[path] = tvdb_id else: shows.append(show) except ArrException: invalid.append(item) if len(shows) == 100 or len(tvdb_ids) == i: try: _a, _e, _i = self.api.add_multiple_series(shows, folder, quality_profile, language_profile, monitor, season, search, cutoff_search, series, tags, per_request=100) added.extend(_a) exists.extend(_e) invalid.extend(_i) shows = [] except Invalid as e: raise Failed(f"Sonarr Error: {e}") if len(added) > 0: logger.info("") for series in added: logger.info( f"Added to Sonarr | {series.tvdbId:<6} | {series.title}") if self.config.Cache: self.config.Cache.update_sonarr_adds( series.tvdbId, self.library.original_mapping_name) logger.info(f"{len(added)} Series added to Sonarr") if len(exists) > 0 or len(skipped) > 0: logger.info("") if len(exists) > 0: for series in exists: logger.info( f"Already in Sonarr | {series.tvdbId:<6} | {series.title}" ) if self.config.Cache: self.config.Cache.update_sonarr_adds( series.tvdbId, self.library.original_mapping_name) if len(skipped) > 0: for series in skipped: logger.info(f"Skipped: In Cache | {series}") logger.info( f"{len(exists) + len(skipped)} Series already exist in Sonarr") if len(mismatched) > 0: logger.info("") logger.info( "Items in Plex that have already been added to Sonarr but under a different TVDb ID then in Plex" ) for path, tmdb_id in mismatched.items(): logger.info( f"Plex TVDb ID: {tmdb_id:<7} | Sonarr TVDb ID: {arr_paths[path]:<7} | Path: {path}" ) logger.info(f"{len(mismatched)} Series with mismatched TVDb IDs") if len(path_in_use) > 0: logger.info("") logger.info( "TVDb IDs that cannot be added to Sonarr because the path they will use is already in use by a different TVDb ID" ) for path, tvdb_id in path_in_use.items(): logger.info( f"TVDb ID: {tvdb_id:<7} | Sonarr TVDb ID: {arr_paths[path]:<7} | Path: {path}" ) logger.info( f"{len(path_in_use)} Series with paths already in use by other TVDb IDs" ) if len(invalid) > 0: for tvdb_id in invalid: logger.info("") logger.info(f"Invalid TVDb ID | {tvdb_id}") logger.info(f"{len(invalid)} Series with Invalid IDs") return len(added)
def start(attrs): file_logger = os.path.join(default_dir, "logs", "meta.log") should_roll_over = os.path.isfile(file_logger) file_handler = RotatingFileHandler(file_logger, delay=True, mode="w", backupCount=10, encoding="utf-8") util.apply_formatter(file_handler) file_handler.addFilter(fmt_filter) if should_roll_over: file_handler.doRollover() logger.addHandler(file_handler) util.separator() logger.info("") logger.info(util.centered(" ____ _ __ __ _ __ __ ")) logger.info(util.centered("| _ \\| | _____ __ | \\/ | ___| |_ __ _ | \\/ | __ _ _ __ __ _ __ _ ___ _ __ ")) logger.info(util.centered("| |_) | |/ _ \\ \\/ / | |\\/| |/ _ \\ __/ _` | | |\\/| |/ _` | '_ \\ / _` |/ _` |/ _ \\ '__|")) logger.info(util.centered("| __/| | __/> < | | | | __/ || (_| | | | | | (_| | | | | (_| | (_| | __/ | ")) logger.info(util.centered("|_| |_|\\___/_/\\_\\ |_| |_|\\___|\\__\\__,_| |_| |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_| ")) logger.info(util.centered(" |___/ ")) logger.info(f" Version: {version}") if "time" in attrs and attrs["time"]: start_type = f"{attrs['time']} " elif "test" in attrs and attrs["test"]: start_type = "Test " elif "collections" in attrs and attrs["collections"]: start_type = "Collections " elif "libraries" in attrs and attrs["libraries"]: start_type = "Libraries " else: start_type = "" start_time = datetime.now() if "time" not in attrs: attrs["time"] = start_time.strftime("%H:%M") attrs["time_obj"] = start_time util.separator(debug=True) logger.debug(f"--config (PMM_CONFIG): {config_file}") logger.debug(f"--time (PMM_TIME): {times}") logger.debug(f"--run (PMM_RUN): {run}") logger.debug(f"--run-tests (PMM_TEST): {test}") logger.debug(f"--collections-only (PMM_COLLECTIONS_ONLY): {collection_only}") logger.debug(f"--libraries-only (PMM_LIBRARIES_ONLY): {library_only}") logger.debug(f"--run-collections (PMM_COLLECTIONS): {collections}") logger.debug(f"--run-libraries (PMM_LIBRARIES): {libraries}") logger.debug(f"--resume (PMM_RESUME): {resume}") logger.debug(f"--no-countdown (PMM_NO_COUNTDOWN): {no_countdown}") logger.debug(f"--no-missing (PMM_NO_MISSING): {no_missing}") logger.debug(f"--divider (PMM_DIVIDER): {divider}") logger.debug(f"--width (PMM_WIDTH): {screen_width}") logger.debug(f"--debug (PMM_DEBUG): {debug}") logger.debug(f"--trace (PMM_TRACE): {trace}") logger.debug("") util.separator(f"Starting {start_type}Run") config = None global stats stats = {"created": 0, "modified": 0, "deleted": 0, "added": 0, "removed": 0, "radarr": 0, "sonarr": 0} try: config = Config(default_dir, attrs) except Exception as e: util.print_stacktrace() util.print_multiline(e, critical=True) else: try: update_libraries(config) except Exception as e: config.notify(e) util.print_stacktrace() util.print_multiline(e, critical=True) logger.info("") end_time = datetime.now() run_time = str(end_time - start_time).split('.')[0] if config: try: config.Webhooks.end_time_hooks(start_time, end_time, run_time, stats) except Failed as e: util.print_stacktrace() logger.error(f"Webhooks Error: {e}") util.separator(f"Finished {start_type}Run\nRun Time: {run_time}") logger.removeHandler(file_handler)