def validate_anidb_id(self, anidb_id, language): response = self.send_request( "{}/{}".format(self.urls["anime"], anidb_id), language) ids = response.xpath("//*[text()='a{}']/text()".format(anidb_id)) if len(ids) > 0: return util.regex_first_int(ids[0], "AniDB ID") raise Failed("AniDB Error: AniDB ID: {} not found".format(anidb_id))
def _validate(self, anidb_id, language): response = self._request(f"{urls['anime']}/{anidb_id}", language=language) ids = response.xpath(f"//*[text()='a{anidb_id}']/text()") if len(ids) > 0: return util.regex_first_int(ids[0], "AniDB ID") raise Failed(f"AniDB Error: AniDB ID: {anidb_id} not found")
def __init__(self, tvdb_url, language, is_movie, TVDb): tvdb_url = tvdb_url.strip() if not is_movie and tvdb_url.startswith( (TVDb.series_url, TVDb.alt_series_url, TVDb.series_id_url)): self.media_type = "Series" elif is_movie and tvdb_url.startswith( (TVDb.movies_url, TVDb.alt_movies_url, TVDb.movie_id_url)): self.media_type = "Movie" else: raise Failed("TVDb Error: {} must begin with {}".format( tvdb_url, TVDb.movies_url if is_movie else TVDb.series_url)) response = TVDb.send_request(tvdb_url, language) results = response.xpath( "//*[text()='TheTVDB.com {} ID']/parent::node()/span/text()". format(self.media_type)) if len(results) > 0: self.id = int(results[0]) else: raise Failed( "TVDb Error: Could not find a TVDb {} ID at the URL {}".format( self.media_type, tvdb_url)) results = response.xpath( "//div[@class='change_translation_text' and @data-language='eng']/@data-title" ) if len(results) > 0 and len(results[0]) > 0: self.title = results[0] else: raise Failed("TVDb Error: Name not found from TVDb URL: {}".format( tvdb_url)) results = response.xpath( "//div[@class='row hidden-xs hidden-sm']/div/img/@src") self.poster_path = results[0] if len(results) > 0 and len( results[0]) > 0 else None tmdb_id = None if is_movie: results = response.xpath("//*[text()='TheMovieDB.com']/@href") if len(results) > 0: try: tmdb_id = util.regex_first_int(results[0], "TMDb ID") except Failed as e: logger.error(e) if not tmdb_id: results = response.xpath("//*[text()='IMDB']/@href") if len(results) > 0: try: tmdb_id = TVDb.convert_from_imdb( util.get_id_from_imdb_url(results[0]), language) except Failed as e: logger.error(e) self.tmdb_id = tmdb_id self.tvdb_url = tvdb_url self.language = language self.is_movie = is_movie self.TVDb = TVDb
def get_tmdb(self, letterboxd_url, language): response = self.send_request(letterboxd_url, language) ids = response.xpath("//a[@data-track-action='TMDb']/@href") if len(ids) > 0 and ids[0]: if "themoviedb.org/movie" in ids[0]: return util.regex_first_int(ids[0], "TMDB Movie ID") raise Failed( f"Letterboxd Error: TMDb Movie ID not found in {ids[0]}") raise Failed( f"Letterboxd Error: TMDb Movie ID not found at {letterboxd_url}")
def _tmdb(self, flixpatrol_url, language): ids = self._request(flixpatrol_url, language, "//script[@type='application/ld+json']/text()") if len(ids) > 0 and ids[0]: if "https://www.themoviedb.org" in ids[0]: return util.regex_first_int( ids[0].split("https://www.themoviedb.org")[1], "TMDb Movie ID") raise Failed( f"FlixPatrol Error: TMDb Movie ID not found at {flixpatrol_url}")
def _tmdb(self, letterboxd_url, language): if self.config.trace_mode: logger.debug(f"URL: {letterboxd_url}") response = self.config.get_html(letterboxd_url, headers=util.header(language)) ids = response.xpath("//a[@data-track-action='TMDb']/@href") if len(ids) > 0 and ids[0]: if "themoviedb.org/movie" in ids[0]: return util.regex_first_int(ids[0], "TMDb Movie ID") raise Failed( f"Letterboxd Error: TMDb Movie ID not found in {ids[0]}") raise Failed( f"Letterboxd Error: TMDb Movie ID not found at {letterboxd_url}")
def __init__(self, tvdb_url, language, is_movie, TVDb): tvdb_url = tvdb_url.strip() if not is_movie and tvdb_url.startswith( (TVDb.series_url, TVDb.alt_series_url, TVDb.series_id_url)): self.media_type = "Series" elif is_movie and tvdb_url.startswith( (TVDb.movies_url, TVDb.alt_movies_url, TVDb.movie_id_url)): self.media_type = "Movie" else: raise Failed( f"TVDb Error: {tvdb_url} must begin with {TVDb.movies_url if is_movie else TVDb.series_url}" ) response = TVDb.send_request(tvdb_url, language) results = response.xpath( f"//*[text()='TheTVDB.com {self.media_type} ID']/parent::node()/span/text()" ) if len(results) > 0: self.id = int(results[0]) elif tvdb_url.startswith(TVDb.movie_id_url): raise Failed( f"TVDb Error: Could not find a TVDb Movie using TVDb Movie ID: {tvdb_url[len(TVDb.movie_id_url):]}" ) elif tvdb_url.startswith(TVDb.series_id_url): raise Failed( f"TVDb Error: Could not find a TVDb Series using TVDb Series ID: {tvdb_url[len(TVDb.series_id_url):]}" ) else: raise Failed( f"TVDb Error: Could not find a TVDb {self.media_type} ID at the URL {tvdb_url}" ) results = response.xpath( "//div[@class='change_translation_text' and @data-language='eng']/@data-title" ) if len(results) > 0 and len(results[0]) > 0: self.title = results[0] else: raise Failed( f"TVDb Error: Name not found from TVDb URL: {tvdb_url}") results = response.xpath( "//div[@class='row hidden-xs hidden-sm']/div/img/@src") self.poster_path = results[0] if len(results) > 0 and len( results[0]) > 0 else None results = response.xpath( "(//h2[@class='mt-4' and text()='Backgrounds']/following::div/a/@href)[1]" ) self.background_path = results[0] if len(results) > 0 and len( results[0]) > 0 else None results = response.xpath( "//div[@class='block']/div[not(@style='display:none')]/p/text()") self.summary = results[0] if len(results) > 0 and len( results[0]) > 0 else None tmdb_id = None if is_movie: results = response.xpath("//*[text()='TheMovieDB.com']/@href") if len(results) > 0: try: tmdb_id = util.regex_first_int(results[0], "TMDb ID") except Failed as e: logger.error(e) if not tmdb_id: results = response.xpath("//*[text()='IMDB']/@href") if len(results) > 0: try: tmdb_id, _ = TVDb.config.Arms.imdb_to_ids( util.get_id_from_imdb_url(results[0]), language) except Failed as e: logger.error(e) self.tmdb_id = tmdb_id self.tvdb_url = tvdb_url self.language = language self.is_movie = is_movie self.TVDb = TVDb
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 __init__(self, tvdb_url, language, is_movie, config): self.tvdb_url = tvdb_url.strip() self.language = language self.is_movie = is_movie self.config = config if not self.is_movie and self.tvdb_url.startswith( (urls["series"], urls["alt_series"], urls["series_id"])): self.media_type = "Series" elif self.is_movie and self.tvdb_url.startswith( (urls["movies"], urls["alt_movies"], urls["movie_id"])): self.media_type = "Movie" else: raise Failed( f"TVDb Error: {self.tvdb_url} must begin with {urls['movies'] if self.is_movie else urls['series']}" ) if self.config.trace_mode: logger.debug(f"URL: {tvdb_url}") response = self.config.get_html(self.tvdb_url, headers=util.header(self.language)) results = response.xpath( f"//*[text()='TheTVDB.com {self.media_type} ID']/parent::node()/span/text()" ) if len(results) > 0: self.id = int(results[0]) elif self.tvdb_url.startswith(urls["movie_id"]): raise Failed( f"TVDb Error: Could not find a TVDb Movie using TVDb Movie ID: {self.tvdb_url[len(urls['movie_id']):]}" ) elif self.tvdb_url.startswith(urls["series_id"]): raise Failed( f"TVDb Error: Could not find a TVDb Series using TVDb Series ID: {self.tvdb_url[len(urls['series_id']):]}" ) else: raise Failed( f"TVDb Error: Could not find a TVDb {self.media_type} ID at the URL {self.tvdb_url}" ) def parse_page(xpath): parse_results = response.xpath(xpath) if len(parse_results) > 0: parse_results = [ r.strip() for r in parse_results if len(r) > 0 ] return parse_results[0] if len(parse_results) > 0 else None def parse_title_summary(lang=None): place = "//div[@class='change_translation_text' and " place += f"@data-language='{lang}']" if lang else "not(@style='display:none')]" return parse_page(f"{place}/@data-title"), parse_page( f"{place}/p/text()[normalize-space()]") self.title, self.summary = parse_title_summary(lang=self.language) if not self.title and self.language in language_translation: self.title, self.summary = parse_title_summary( lang=language_translation[self.language]) if not self.title: self.title, self.summary = parse_title_summary() if not self.title: raise Failed( f"TVDb Error: Name not found from TVDb URL: {self.tvdb_url}") self.poster_path = parse_page( "//div[@class='row hidden-xs hidden-sm']/div/img/@src") self.background_path = parse_page( "(//h2[@class='mt-4' and text()='Backgrounds']/following::div/a/@href)[1]" ) if self.is_movie: self.directors = parse_page( "//strong[text()='Directors']/parent::li/span/a/text()[normalize-space()]" ) self.writers = parse_page( "//strong[text()='Writers']/parent::li/span/a/text()[normalize-space()]" ) self.studios = parse_page( "//strong[text()='Studio']/parent::li/span/a/text()[normalize-space()]" ) else: self.networks = parse_page( "//strong[text()='Networks']/parent::li/span/a/text()[normalize-space()]" ) self.genres = parse_page( "//strong[text()='Genres']/parent::li/span/a/text()[normalize-space()]" ) tmdb_id = None imdb_id = None if self.is_movie: results = response.xpath("//*[text()='TheMovieDB.com']/@href") if len(results) > 0: try: tmdb_id = util.regex_first_int(results[0], "TMDb ID") except Failed: pass results = response.xpath("//*[text()='IMDB']/@href") if len(results) > 0: try: imdb_id = util.get_id_from_imdb_url(results[0]) except Failed: pass if tmdb_id is None and imdb_id is None: raise Failed( f"TVDB Error: No TMDb ID or IMDb ID found for {self.title}" ) self.tmdb_id = tmdb_id self.imdb_id = imdb_id
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 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")