[31] update overlays to remove the old overlays automatically

VERSION

@@ -1 +1 @@
-1.16.5-develop30
+1.16.5-develop31

modules/builder.py

@@ -1272,7 +1272,7 @@ class CollectionBuilder:
                 new_dictionary = {}
                 if method_name == "plex_search":
                     type_override = f"{self.collection_level}s" if self.collection_level in plex.collection_level_options else None
-                    new_dictionary = self.build_filter("plex_search", dict_data, type_override=type_override)
+                    new_dictionary = self.build_filter("plex_search", dict_data, type_override=type_override, default_sort="season.asc" if self.collection_level == "season" else "title.asc")
                 elif method_name == "plex_collectionless":
                     prefix_list = util.parse(self.Type, "exclude_prefix", dict_data, datatype="list", methods=dict_methods) if "exclude_prefix" in dict_methods else []
                     exact_list = util.parse(self.Type, "exclude", dict_data, datatype="list", methods=dict_methods) if "exclude" in dict_methods else []
@@ -2202,7 +2202,7 @@ class CollectionBuilder:
                     if filter_attr == "audio_track_title":
                         for media in item.media:
                             for part in media.parts:
-                                values.extend([a.title for a in part.audioStreams() if a.title])
+                                values.extend([a.extendedDisplayTitle for a in part.audioStreams() if a.extendedDisplayTitle])
                     elif filter_attr == "filepath":
                         values = [loc for loc in item.locations]
                     else:
@@ -2403,20 +2403,6 @@ class CollectionBuilder:
         logger.info("")
         logger.separator(f"Updating Details of the Items in {self.name} {self.Type}", space=False, border=False)
         logger.info("")
-        overlay = None
-        overlay_folder = None
-        overlay_name = ""
-        rating_keys = []
-        if "item_overlay" in self.item_details:
-            overlay_name = self.item_details["item_overlay"]
-            rating_keys = [int(item.ratingKey) for item in self.library.search(label=f"{overlay_name} Overlay")]
-            overlay_folder = os.path.join(self.config.default_dir, "overlays", overlay_name)
-            overlay_image = Image.open(os.path.join(overlay_folder, "overlay.png")).convert("RGBA")
-            overlay = (overlay_name, overlay_folder, overlay_image)
-
-        revert = "revert_overlay" in self.item_details
-        if revert:
-            overlay = None
 
         add_tags = self.item_details["item_label"] if "item_label" in self.item_details else None
         remove_tags = self.item_details["item_label.remove"] if "item_label.remove" in self.item_details else None
@@ -2432,14 +2418,6 @@ class CollectionBuilder:
         tmdb_paths = []
         tvdb_paths = []
         for item in self.items:
-            if int(item.ratingKey) in rating_keys and not revert:
-                rating_keys.remove(int(item.ratingKey))
-            if overlay is not None:
-                try:
-                    self.library.update_asset(item, overlay=overlay, folders=self.details["asset_folders"],
-                                              create=self.details["create_asset_folders"], asset_directory=self.asset_directory)
-                except Failed as e:
-                    logger.error(e)
             self.library.edit_tags("label", item, add_tags=add_tags, remove_tags=remove_tags, sync_tags=sync_tags)
             path = os.path.dirname(str(item.locations[0])) if self.library.is_movie else str(item.locations[0])
             if self.library.Radarr and item.ratingKey in self.library.movie_rating_key_map:
@@ -2498,19 +2476,6 @@ class CollectionBuilder:
                 added = self.library.Sonarr.add_tvdb(tvdb_paths, **self.sonarr_details)
                 self.added_to_sonarr.extend([{"title": show.title, "id": show.tvdbId} for show in added])
 
-        for rating_key in rating_keys:
-            try:
-                item = self.fetch_item(rating_key)
-            except Failed as e:
-                logger.error(e)
-                continue
-            self.library.edit_tags("label", item, remove_tags=[f"{overlay_name} Overlay"])
-            og_image = os.path.join(overlay_folder, f"{rating_key}.png")
-            if os.path.exists(og_image):
-                self.library.upload_poster(item, og_image)
-                os.remove(og_image)
-            self.config.Cache.update_image_map(item.ratingKey, self.library.image_table_name, "", "")
-
     def load_collection(self):
         if self.obj is None and self.smart_url:
             self.library.create_smart_collection(self.name, self.smart_type_key, self.smart_url)

modules/config.py

@@ -757,7 +757,9 @@ class ConfigFile:
                         if not files:
                             raise Failed("Config Error: No Paths Found for overlay_path")
                         for file in util.get_list(lib["overlay_path"], split=False):
-                            if isinstance(file, dict) and "remove_overlays" in file and file["remove_overlays"] is True:
+                            if isinstance(file, dict) \
+                                    and ("remove_overlays" in file and file["remove_overlays"] is True) \
+                                    or ("revert_overlays" in file and file["revert_overlays"] is True):
                                 params["remove_overlays"] = True
                         params["overlay_path"] = files
 

modules/imdb.py

@@ -18,7 +18,6 @@ charts = {
     "top_indian": "Top Rated Indian Movies",
     "lowest_rated": "Lowest Rated Movies"
 }
-
 base_url = "https://www.imdb.com"
 urls = {
     "lists": f"{base_url}/list/ls",
@@ -136,7 +135,7 @@ class IMDb:
             if parental_dict and expired is False:
                 return parental_dict
         response = self.config.get_html(f"https://www.imdb.com/title/{imdb_id}/parentalguide")
-        for ptype in ["nudity", "violence", "profanity", "alcohol", "frightening"]:
+        for ptype in util.parental_types:
             results = response.xpath(f"//section[@id='advisory-{ptype}']//span[contains(@class,'ipl-status-pill')]/text()")
             if results:
                 parental_dict[ptype] = results[0].strip()

modules/operations.py

@@ -73,8 +73,11 @@ class Operations:
                     logger.error(e)
                     continue
                 logger.ghost(f"Processing: {i}/{len(items)} {item.title}")
-                if self.library.assets_for_all:
+                current_labels = [la.tag for la in item.labels] if self.library.assets_for_all or self.library.mass_imdb_parental_labels else []
-                    self.library.update_asset2(item)
+
+                if self.library.assets_for_all and "Overlay" not in current_labels:
+                    self.library.update_asset(item)
+
                 tmdb_id, tvdb_id, imdb_id = self.library.get_ids(item)
 
                 item.batchEdits()
@@ -103,8 +106,11 @@ class Operations:
                 if self.library.mass_imdb_parental_labels:
                     try:
                         parental_guide = self.config.IMDb.parental_guide(imdb_id)
-                        labels = [f"{k.capitalize()}:{v}" for k, v in parental_guide.items() if self.library.mass_imdb_parental_labels == "with_none" or v != "None"]
+                        parental_labels = [f"{k.capitalize()}:{v}" for k, v in parental_guide.items() if self.library.mass_imdb_parental_labels == "with_none" or v != "None"]
-                        batch_display += f"\n{self.library.edit_tags('label', item, add_tags=labels)}"
+                        add_labels = [la for la in parental_labels if la not in current_labels]
+                        remove_labels = [la for la in current_labels if la in util.parental_labels and la not in parental_labels]
+                        if add_labels or remove_labels:
+                            batch_display += f"\n{self.library.edit_tags('label', item, add_tags=add_labels, remove_tags=remove_labels)}"
                     except Failed:
                         pass
 
@@ -375,7 +381,7 @@ class Operations:
             logger.separator(f"Unmanaged Collection Assets Check for {self.library.name} Library", space=False, border=False)
             logger.info("")
             for col in unmanaged_collections:
-                self.library.update_asset2(col)
+                self.library.update_asset(col)
         if self.library.mass_collection_mode:
             logger.info("")
             logger.separator(f"Unmanaged Mass Collection Mode for {self.library.name} Library", space=False, border=False)

modules/overlays.py

@@ -19,153 +19,47 @@ class Overlays:
         logger.separator(f"{self.library.name} Library Overlays")
         logger.info("")
         os.makedirs(self.library.overlay_backup, exist_ok=True)
-        key_to_item = {}
+
-        key_to_overlays = {}
+        old_overlays = [l for l in self.library.Plex.listFilterChoices("label") if str(l.title).lower().endswith(" overlay")]
-        settings = {}
+        if old_overlays:
-        if self.library.remove_overlays:
             logger.info("")
-            logger.separator(f"Removing Overlays for the {self.library.name} Library")
+            logger.separator(f"Removing Old Overlays for the {self.library.name} Library")
             logger.info("")
-        else:
+            for old_overlay in old_overlays:
-            for overlay_file in self.library.overlay_files:
+                label_items = self.get_overlay_items(label=old_overlay)
-                for k, v in overlay_file.overlays.items():
+                if label_items:
-                    try:
-                        builder = CollectionBuilder(self.config, overlay_file, k, v, library=self.library, overlay=True)
                     logger.info("")
-
+                    logger.separator(f"Removing {old_overlay.title}")
-                        logger.separator(f"Gathering Items for {k} Overlay", space=False, border=False)
-
-                        if builder.overlay not in settings:
-                            settings[builder.overlay] = {
-                                "keys": [], "suppress": builder.suppress_overlays, "group": builder.overlay_group,
-                                "weight": builder.overlay_weight, "path": builder.overlay_path, "updated": False, "image": None
-                            }
-
-                        for method, value in builder.builders:
-                            logger.debug("")
-                            logger.debug(f"Builder: {method}: {value}")
                     logger.info("")
-                            builder.filter_and_save_items(builder.gather_ids(method, value))
+                    for i, item in enumerate(label_items, 1):
-
+                        logger.ghost(f"Restoring {old_overlay.title}: {i}/{len(label_items)} {item.title}")
-                        if builder.filters or builder.tmdb_filters:
+                        self.remove_overlay(item, old_overlay.title, [
-                            logger.info("")
+                            os.path.join(self.library.overlay_folder, old_overlay.title[:-8], f"{item.ratingKey}.png")
-                            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}")
-
-                        added_titles = []
-                        if builder.added_items:
-                            for item in builder.added_items:
-                                key_to_item[item.ratingKey] = item
-                                added_titles.append(item.title)
-                                if item.ratingKey not in settings[builder.overlay]["keys"]:
-                                    settings[builder.overlay]["keys"].append(item.ratingKey)
-                        if added_titles:
-                            logger.debug(f"{len(added_titles)} Titles Found: {added_titles}")
-                        logger.info(f"{len(added_titles) if added_titles else 'No'} Items found for {builder.overlay}")
-                    except Failed as e:
-                        logger.error(e)
-
-            overlay_groups = {}
-            for overlay_name, over_attrs in settings.items():
-                if over_attrs["group"]:
-                    if over_attrs["group"] not in overlay_groups:
-                        overlay_groups[over_attrs["group"]] = {}
-                    overlay_groups[over_attrs["group"]][overlay_name] = over_attrs["weight"]
-                for rk in over_attrs["keys"]:
-                    for suppress_name in over_attrs["suppress"]:
-                        if suppress_name in settings and rk in settings[suppress_name]["keys"]:
-                            settings[suppress_name]["keys"].remove(rk)
-                if not overlay_name.startswith("blur"):
-                    image_compare = None
-                    if self.config.Cache:
-                        _, image_compare, _ = self.config.Cache.query_image_map(overlay_name, f"{self.library.image_table_name}_overlays")
-                    overlay_size = os.stat(settings[overlay_name]["path"]).st_size
-                    settings[overlay_name]["updated"] = not image_compare or str(overlay_size) != str(image_compare)
-                    settings[overlay_name]["image"] = Image.open(settings[overlay_name]["path"]).convert("RGBA")
-                    if self.config.Cache:
-                        self.config.Cache.update_image_map(overlay_name, f"{self.library.image_table_name}_overlays", overlay_name, overlay_size)
-
-            for overlay_name, over_attrs in settings.items():
-                for over_key in over_attrs["keys"]:
-                    if over_key not in key_to_overlays:
-                        key_to_overlays[over_key] = (key_to_item[over_key], [])
-                    key_to_overlays[over_key][1].append(overlay_name)
-
-            for over_key, (item, over_names) in key_to_overlays.items():
-                group_status = {}
-                for over_name in over_names:
-                    for overlay_group, group_names in overlay_groups.items():
-                        if over_name in group_names:
-                            if overlay_group not in group_status:
-                                group_status[overlay_group] = []
-                            group_status[overlay_group].append(over_name)
-                for gk, gv in group_status.items():
-                    if len(gv) > 1:
-                        final = None
-                        for v in gv:
-                            if final is None or overlay_groups[gk][v] > overlay_groups[gk][final]:
-                                final = v
-                        for v in gv:
-                            if final != v:
-                                key_to_overlays[over_key][1].remove(v)
 
-        def find_poster_url(plex_item):
+        if self.library.remove_overlays:
-            if isinstance(plex_item, Movie):
+            remove_overlays = self.get_overlay_items()
-                if plex_item.ratingKey in self.library.movie_rating_key_map:
-                    return self.config.TMDb.get_movie(self.library.movie_rating_key_map[plex_item.ratingKey]).poster_url
-            elif isinstance(plex_item, (Show, Season, Episode)):
-                check_key = plex_item.ratingKey if isinstance(plex_item, Show) else plex_item.show().ratingKey
-                tmdb_id = self.config.Convert.tvdb_to_tmdb(self.library.show_rating_key_map[check_key])
-                if isinstance(plex_item, Show) and plex_item.ratingKey in self.library.show_rating_key_map:
-                    return self.config.TMDb.get_show(tmdb_id).poster_url
-                elif isinstance(plex_item, Season):
-                    return self.config.TMDb.get_season(tmdb_id, plex_item.seasonNumber).poster_url
-                elif isinstance(plex_item, Episode):
-                    return self.config.TMDb.get_episode(tmdb_id, plex_item.seasonNumber, plex_item.episodeNumber).still_url
-
-        def get_overlay_items(libtype=None):
-            return [o for o in self.library.search(label="Overlay", libtype=libtype) if o.ratingKey not in key_to_overlays]
-
-        remove_overlays = get_overlay_items()
             if self.library.is_show:
-            remove_overlays.extend(get_overlay_items(libtype="episode"))
+                remove_overlays.extend(self.get_overlay_items(libtype="episode"))
-            remove_overlays.extend(get_overlay_items(libtype="season"))
+                remove_overlays.extend(self.get_overlay_items(libtype="season"))
             elif self.library.is_music:
-            remove_overlays.extend(get_overlay_items(libtype="album"))
+                remove_overlays.extend(self.get_overlay_items(libtype="album"))
 
+            logger.info("")
+            if remove_overlays:
+                logger.separator(f"Removing Overlays for the {self.library.name} Library")
                 for i, item in enumerate(remove_overlays, 1):
                     logger.ghost(f"Restoring: {i}/{len(remove_overlays)} {item.title}")
-            clean_name, _ = util.validate_filename(item.title)
+                    self.remove_overlay(item, "Overlay", [
-            poster, _, item_dir = self.library.find_assets(
+                        os.path.join(self.library.overlay_backup, f"{item.ratingKey}.png"),
-                name="poster" if self.library.asset_folders else clean_name,
+                        os.path.join(self.library.overlay_backup, f"{item.ratingKey}.jpg")
-                folder_name=clean_name if self.library.asset_folders else None,
+                    ])
-                prefix=f"{item.title}'s "
+                logger.exorcise()
-            )
-            is_url = False
-            original = None
-            if poster:
-                poster_location = poster.location
-            elif os.path.exists(os.path.join(self.library.overlay_backup, f"{item.ratingKey}.png")):
-                original = os.path.join(self.library.overlay_backup, f"{item.ratingKey}.png")
-                poster_location = original
-            elif os.path.exists(os.path.join(self.library.overlay_backup, f"{item.ratingKey}.jpg")):
-                original = os.path.join(self.library.overlay_backup, f"{item.ratingKey}.jpg")
-                poster_location = original
             else:
-                is_url = True
+                logger.separator(f"No Overlays to Remove for the {self.library.name} Library")
-                poster_location = find_poster_url(item)
+            logger.info("")
-            if poster_location:
-                self.library.upload_poster(item, poster_location, url=is_url)
-                self.library.edit_tags("label", item, remove_tags=["Overlay"], do_print=False)
-                if original:
-                    os.remove(original)
         else:
-                logger.error(f"No Poster found to restore for {item.title}")
+            key_to_overlays, properties = self.compile_overlays()
-        logger.exorcise()
-
-        if key_to_overlays:
             logger.info("")
             logger.separator(f"Applying Overlays for the {self.library.name} Library")
             logger.info("")
@@ -187,15 +81,10 @@ class Overlays:
                                 overlay_change = True
                     if not overlay_change:
                         for over_name in over_names:
-                            if over_name not in overlay_compare or settings[over_name]["updated"]:
+                            if over_name not in overlay_compare or properties[over_name]["updated"]:
                                 overlay_change = True
 
-                    clean_name, _ = util.validate_filename(item.title)
+                    poster, _, item_dir = self.find_asset(item)
-                    poster, _, item_dir = self.library.find_assets(
-                        name="poster" if self.library.asset_folders else clean_name,
-                        folder_name=clean_name if self.library.asset_folders else None,
-                        prefix=f"{item.title}'s "
-                    )
 
                     has_original = None
                     changed_image = False
@@ -209,7 +98,7 @@ class Overlays:
                         elif os.path.exists(os.path.join(self.library.overlay_backup, f"{item.ratingKey}.jpg")):
                             has_original = os.path.join(self.library.overlay_backup, f"{item.ratingKey}.jpg")
                         else:
-                            new_backup = find_poster_url(item)
+                            new_backup = self.find_poster_url(item)
                             if new_backup is None:
                                 new_backup = item.posterUrl
                     else:
@@ -244,8 +133,8 @@ class Overlays:
                                 new_poster = new_poster.filter(ImageFilter.GaussianBlur(blur_num))
                             for over_name in over_names:
                                 if not over_name.startswith("blur"):
-                                    new_poster = new_poster.resize(settings[over_name]["image"].size, Image.ANTIALIAS)
+                                    new_poster = new_poster.resize(properties[over_name]["image"].size, Image.ANTIALIAS)
-                                    new_poster.paste(settings[over_name]["image"], (0, 0), settings[over_name]["image"])
+                                    new_poster.paste(properties[over_name]["image"], (0, 0), properties[over_name]["image"])
                             new_poster.save(temp, "PNG")
                             self.library.upload_poster(item, temp)
                             self.library.edit_tags("label", item, add_tags=["Overlay"], do_print=False)
@@ -262,3 +151,140 @@ class Overlays:
                 except Failed as e:
                     logger.error(e)
         logger.exorcise()
+
+    def compile_overlays(self):
+        key_to_item = {}
+        properties = {}
+        overlay_groups = {}
+        key_to_overlays = {}
+
+        for overlay_file in self.library.overlay_files:
+            for k, v in overlay_file.overlays.items():
+                try:
+                    builder = CollectionBuilder(self.config, overlay_file, k, v, library=self.library, overlay=True)
+                    logger.info("")
+
+                    logger.separator(f"Gathering Items for {k} Overlay", space=False, border=False)
+
+                    if builder.overlay not in properties:
+                        properties[builder.overlay] = {
+                            "keys": [], "suppress": builder.suppress_overlays, "group": builder.overlay_group,
+                            "weight": builder.overlay_weight, "path": builder.overlay_path, "updated": False,
+                            "image": None
+                        }
+
+                    for method, value in builder.builders:
+                        logger.debug("")
+                        logger.debug(f"Builder: {method}: {value}")
+                        logger.info("")
+                        builder.filter_and_save_items(builder.gather_ids(method, value))
+
+                    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}")
+
+                    added_titles = []
+                    if builder.added_items:
+                        for item in builder.added_items:
+                            key_to_item[item.ratingKey] = item
+                            added_titles.append(item.title)
+                            if item.ratingKey not in properties[builder.overlay]["keys"]:
+                                properties[builder.overlay]["keys"].append(item.ratingKey)
+                    if added_titles:
+                        logger.debug(f"{len(added_titles)} Titles Found: {added_titles}")
+                    logger.info(f"{len(added_titles) if added_titles else 'No'} Items found for {builder.overlay}")
+                except Failed as e:
+                    logger.error(e)
+
+        for overlay_name, over_attrs in properties.items():
+            if over_attrs["group"]:
+                if over_attrs["group"] not in overlay_groups:
+                    overlay_groups[over_attrs["group"]] = {}
+                overlay_groups[over_attrs["group"]][overlay_name] = over_attrs["weight"]
+            for rk in over_attrs["keys"]:
+                for suppress_name in over_attrs["suppress"]:
+                    if suppress_name in properties and rk in properties[suppress_name]["keys"]:
+                        properties[suppress_name]["keys"].remove(rk)
+            if not overlay_name.startswith("blur"):
+                image_compare = None
+                if self.config.Cache:
+                    _, image_compare, _ = self.config.Cache.query_image_map(overlay_name, f"{self.library.image_table_name}_overlays")
+                overlay_size = os.stat(properties[overlay_name]["path"]).st_size
+                properties[overlay_name]["updated"] = not image_compare or str(overlay_size) != str(image_compare)
+                properties[overlay_name]["image"] = Image.open(properties[overlay_name]["path"]).convert("RGBA")
+                if self.config.Cache:
+                    self.config.Cache.update_image_map(overlay_name, f"{self.library.image_table_name}_overlays", overlay_name, overlay_size)
+
+        for overlay_name, over_attrs in properties.items():
+            for over_key in over_attrs["keys"]:
+                if over_key not in key_to_overlays:
+                    key_to_overlays[over_key] = (key_to_item[over_key], [])
+                key_to_overlays[over_key][1].append(overlay_name)
+
+        for over_key, (item, over_names) in key_to_overlays.items():
+            group_status = {}
+            for over_name in over_names:
+                for overlay_group, group_names in overlay_groups.items():
+                    if over_name in group_names:
+                        if overlay_group not in group_status:
+                            group_status[overlay_group] = []
+                        group_status[overlay_group].append(over_name)
+            for gk, gv in group_status.items():
+                if len(gv) > 1:
+                    final = None
+                    for v in gv:
+                        if final is None or overlay_groups[gk][v] > overlay_groups[gk][final]:
+                            final = v
+                    for v in gv:
+                        if final != v:
+                            key_to_overlays[over_key][1].remove(v)
+        return key_to_overlays, properties
+
+    def find_asset(self, item):
+        clean_asset_name, _ = util.validate_filename(item.title)
+        return self.library.find_assets(
+            name="poster" if self.library.asset_folders else clean_asset_name,
+            folder_name=clean_asset_name if self.library.asset_folders else None,
+            prefix=f"{item.title}'s "
+        )
+
+    def find_poster_url(self, item):
+        if isinstance(item, Movie):
+            if item.ratingKey in self.library.movie_rating_key_map:
+                return self.config.TMDb.get_movie(self.library.movie_rating_key_map[item.ratingKey]).poster_url
+        elif isinstance(item, (Show, Season, Episode)):
+            check_key = item.ratingKey if isinstance(item, Show) else item.show().ratingKey
+            tmdb_id = self.config.Convert.tvdb_to_tmdb(self.library.show_rating_key_map[check_key])
+            if isinstance(item, Show) and item.ratingKey in self.library.show_rating_key_map:
+                return self.config.TMDb.get_show(tmdb_id).poster_url
+            elif isinstance(item, Season):
+                return self.config.TMDb.get_season(tmdb_id, item.seasonNumber).poster_url
+            elif isinstance(item, Episode):
+                return self.config.TMDb.get_episode(tmdb_id, item.seasonNumber, item.episodeNumber).still_url
+
+    def get_overlay_items(self, label="Overlay", libtype=None, ignore=None):
+        items = self.library.search(label=label, libtype=libtype)
+        return items if not ignore else [o for o in items if o.ratingKey not in ignore]
+
+    def remove_overlay(self, item, label, locations):
+        poster, _, item_dir = self.find_asset(item)
+        is_url = False
+        original = None
+        if poster:
+            poster_location = poster.location
+        elif any([os.path.exists(loc) for loc in locations]):
+            original = next((loc for loc in locations if os.path.exists(loc)))
+            poster_location = original
+        else:
+            is_url = True
+            poster_location = self.find_poster_url(item)
+        if poster_location:
+            self.library.upload_poster(item, poster_location, url=is_url)
+            self.library.edit_tags("label", item, remove_tags=[label], do_print=False)
+            if original:
+                os.remove(original)
+        else:
+            logger.error(f"No Poster found to restore for {item.title}")

modules/plex.py

@@ -809,122 +809,7 @@ class Plex(Library):
                 logger.info(final)
         return final
 
-    def update_asset(self, item, overlay=None, folders=None, create=None, asset_directory=None):
+    def update_asset(self, item, folders=None, create=None, asset_directory=None):
-        if isinstance(item, (Movie, Artist, Show, Episode, Season)):
-            starting = item.show() if isinstance(item, (Episode, Season)) else item
-            path_test = str(starting.locations[0])
-            if not os.path.dirname(path_test):
-                path_test = path_test.replace("\\", "/")
-            name = os.path.basename(os.path.dirname(path_test) if isinstance(starting, Movie) else path_test)
-        elif isinstance(item, (Collection, Playlist)):
-            name = item.title
-        else:
-            return None, None, None
-        if folders is None:
-            folders = self.asset_folders
-        if create is None:
-            create = self.create_asset_folders
-        if asset_directory is None:
-            asset_directory = self.asset_directory
-
-        poster, background, item_dir = self.find_assets(
-            name="poster" if folders else name,
-            folder_name=name if folders else None,
-            prefix=f"{item.title}'s "
-        )
-        if item_dir and self.dimensional_asset_rename and (not poster or not background):
-            for file in util.glob_filter(os.path.join(item_dir, "*.*")):
-                if file.lower().endswith((".jpg", ".png", ".jpeg")):
-                    image = Image.open(file)
-                    _w, _h = image.size
-                    image.close()
-                    if not poster and _h >= _w:
-                        new_path = os.path.join(os.path.dirname(file), f"poster{os.path.splitext(file)[1].lower()}")
-                        os.rename(file, new_path)
-                        poster = ImageData("asset_directory", os.path.abspath(new_path), prefix=f"{item.title}'s ", is_url=False)
-                    elif not background and _w > _h:
-                        new_path = os.path.join(os.path.dirname(file), f"background{os.path.splitext(file)[1].lower()}")
-                        os.rename(file, new_path)
-                        background = ImageData("asset_directory", os.path.abspath(new_path), prefix=f"{item.title}'s ", is_poster=False, is_url=False)
-                    if poster and background:
-                        break
-
-        if poster or background:
-            self.upload_images(item, poster=poster, background=background, overlay=overlay)
-
-        if isinstance(item, Show):
-            missing_seasons = ""
-            missing_episodes = ""
-            found_season = False
-            found_episode = False
-            for season in self.query(item.seasons):
-                season_name = f"Season{'0' if season.seasonNumber < 10 else ''}{season.seasonNumber}"
-                season_poster, season_background, _ = self.find_assets(
-                    name=season_name,
-                    folder_name=name,
-                    item_directory=item_dir,
-                    prefix=f"{item.title} Season {season.seasonNumber}'s "
-                )
-                if season_poster:
-                    found_season = True
-                elif self.show_missing_season_assets and season.seasonNumber > 0:
-                    missing_seasons += f"\nMissing Season {season.seasonNumber} Poster"
-                if season_poster or season_background:
-                    self.upload_images(season, poster=season_poster, background=season_background)
-                for episode in self.query(season.episodes):
-                    if episode.seasonEpisode:
-                        episode_poster, episode_background, _ = self.find_assets(
-                            name=episode.seasonEpisode.upper(),
-                            folder_name=name,
-                            item_directory=item_dir,
-                            prefix=f"{item.title} {episode.seasonEpisode.upper()}'s "
-                        )
-                        if episode_poster:
-                            found_episode = True
-                            self.upload_images(episode, poster=episode_poster, background=episode_background)
-                        elif self.show_missing_episode_assets:
-                            missing_episodes += f"\nMissing {episode.seasonEpisode.upper()} Title Card"
-
-            if (found_season and missing_seasons) or (found_episode and missing_episodes):
-                output = f"Missing Posters for {item.title}"
-                if found_season:
-                    output += missing_seasons
-                if found_episode:
-                    output += missing_episodes
-                logger.info(output)
-        if isinstance(item, Artist):
-            missing_assets = ""
-            found_album = False
-            for album in self.query(item.albums):
-                album_poster, album_background, _ = self.find_assets(
-                    name=album.title,
-                    folder_name=name,
-                    item_directory=item_dir,
-                    prefix=f"{item.title} Album {album.title}'s "
-                )
-                if album_poster:
-                    found_album = True
-                else:
-                    missing_assets += f"\nMissing Album {album.title} Poster"
-                if album_poster or album_background:
-                    self.upload_images(album, poster=album_poster, background=album_background)
-            if self.show_missing_season_assets and found_album and missing_assets:
-                logger.info(f"Missing Album Posters for {item.title}{missing_assets}")
-
-        if isinstance(item, (Movie, Show)) and not poster and overlay:
-            self.upload_images(item, overlay=overlay)
-        if create and folders and item_dir is None:
-            filename, _ = util.validate_filename(name)
-            item_dir = os.path.join(asset_directory[0], filename)
-            os.makedirs(item_dir, exist_ok=True)
-            logger.info(f"Asset Directory Created: {item_dir}")
-        elif isinstance(item, (Movie, Show)) and not overlay and folders and item_dir is None:
-            logger.warning(f"Asset Warning: No asset folder found called '{name}'")
-        elif isinstance(item, (Movie, Show)) and not poster and not background and self.show_missing_assets:
-            logger.warning(f"Asset Warning: No poster or background found in an assets folder for '{name}'")
-        return None, None, item_dir
-
-    def update_asset2(self, item, folders=None, create=None, asset_directory=None):
         if isinstance(item, (Movie, Artist, Show)):
             starting = item.show() if isinstance(item, (Episode, Season)) else item
             path_test = str(starting.locations[0])

modules/util.py

@@ -82,6 +82,9 @@ collection_mode_options = {
     "hide_items": "hideItems", "hideitems": "hideItems",
     "show_items": "showItems", "showitems": "showItems"
 }
+parental_types = ["nudity", "violence", "profanity", "alcohol", "frightening"]
+parental_values = ["None", "Mild", "Moderate", "Severe"]
+parental_labels = [f"{t.capitalize()}:{v}" for t in parental_types for v in parental_values]
 github_base = "https://raw.githubusercontent.com/meisnate12/Plex-Meta-Manager-Configs/master/"
 previous_time = None
 start_time = None