moved mapping method

modules/builder.py

@@ -194,9 +194,9 @@ class CollectionBuilder:
         self.name = name
         self.data = data
         self.details = {
-            "show_filtered": library.show_filtered,
-            "show_missing": library.show_missing,
-            "save_missing": library.save_missing
+            "show_filtered": self.library.show_filtered,
+            "show_missing": self.library.show_missing,
+            "save_missing": self.library.save_missing
         }
         self.item_details = {}
         self.radarr_options = {}
@@ -480,7 +480,7 @@ class CollectionBuilder:
             else:
                 logger.debug(f"Value: {self.data[methods['smart_url']]}")
                 try:
-                    self.smart_url, self.smart_type_key = library.get_smart_filter_from_uri(self.data[methods["smart_url"]])
+                    self.smart_url, self.smart_type_key = self.library.get_smart_filter_from_uri(self.data[methods["smart_url"]])
                 except ValueError:
                     raise Failed("Collection Error: smart_url is incorrectly formatted")
 
@@ -1302,19 +1302,19 @@ class CollectionBuilder:
 
         if self.build_collection:
             try:
-                self.obj = library.get_collection(self.name)
-                collection_smart = library.smart(self.obj)
+                self.obj = self.library.get_collection(self.name)
+                collection_smart = self.library.smart(self.obj)
                 if (self.smart and not collection_smart) or (not self.smart and collection_smart):
                     logger.info("")
                     logger.error(f"Collection Error: Converting {self.obj.title} to a {'smart' if self.smart else 'normal'} collection")
-                    library.query(self.obj.delete)
+                    self.library.query(self.obj.delete)
                     self.obj = None
             except Failed:
                 self.obj = None
 
             self.plex_map = {}
             if self.sync and self.obj:
-                for item in library.get_collection_items(self.obj, self.smart_label_collection):
+                for item in self.library.get_collection_items(self.obj, self.smart_label_collection):
                     self.plex_map[item.ratingKey] = item
         else:
             self.sync = False
@@ -1322,7 +1322,7 @@ class CollectionBuilder:
         logger.info("")
         logger.info("Validation Successful")
 
-    def collect_rating_keys(self, movie_map, show_map):
+    def collect_rating_keys(self):
         def add_rating_keys(keys):
             if not isinstance(keys, list):
                 keys = [keys]
@@ -1338,15 +1338,15 @@ class CollectionBuilder:
                     if len(movie_ids) > 0:
                         items_found_inside += len(movie_ids)
                         for movie_id in movie_ids:
-                            if movie_id in movie_map:
-                                add_rating_keys(movie_map[movie_id])
+                            if movie_id in self.library.movie_map:
+                                add_rating_keys(self.library.movie_map[movie_id])
                             elif movie_id not in self.missing_movies:
                                 self.missing_movies.append(movie_id)
                     if len(show_ids) > 0:
                         items_found_inside += len(show_ids)
                         for show_id in show_ids:
-                            if show_id in show_map:
-                                add_rating_keys(show_map[show_id])
+                            if show_id in self.library.show_map:
+                                add_rating_keys(self.library.show_map[show_id])
                             elif show_id not in self.missing_shows:
                                 self.missing_shows.append(show_id)
                     return items_found_inside
@@ -1365,7 +1365,7 @@ class CollectionBuilder:
                 elif "trakt" in method:                             check_map(self.config.Trakt.get_items(method, value, self.library.is_movie))
                 else:                                               logger.error(f"Collection Error: {method} method not supported")
 
-    def add_to_collection(self, movie_map):
+    def add_to_collection(self):
         name, collection_items = self.library.get_collection_name_and_items(self.obj if self.obj else self.name, self.smart_label_collection)
         total = len(self.rating_keys)
         max_length = len(str(total))
@@ -1391,7 +1391,7 @@ class CollectionBuilder:
                             break
                     elif method_name == "original_language":
                         movie = None
-                        for key, value in movie_map.items():
+                        for key, value in self.library.movie_map.items():
                             if current.ratingKey in value:
                                 try:
                                     movie = self.config.TMDb.get_movie(key)
@@ -1435,7 +1435,7 @@ class CollectionBuilder:
                     elif modifier in [".gte", ".lte"]:
                         if method_name == "vote_count":
                             tmdb_item = None
-                            for key, value in movie_map.items():
+                            for key, value in self.library.movie_map.items():
                                 if current.ratingKey in value:
                                     try:
                                         tmdb_item = self.config.TMDb.get_movie(key) if self.library.is_movie else self.config.TMDb.get_show(key)
@@ -1736,17 +1736,17 @@ class CollectionBuilder:
         elif "tmdb_show_details" in self.backgrounds:       set_image("tmdb_show_details", self.backgrounds, is_background=True)
         else:                                               logger.info("No background to update")
 
-    def run_collections_again(self, movie_map, show_map):
+    def run_collections_again(self):
         self.obj = self.library.get_collection(self.name)
         name, collection_items = self.library.get_collection_name_and_items(self.obj, self.smart_label_collection)
         rating_keys = []
         for mm in self.run_again_movies:
-            if mm in movie_map:
-                rating_keys.extend(movie_map[mm])
+            if mm in self.library.movie_map:
+                rating_keys.extend(self.library.movie_map[mm])
         if self.library.is_show:
             for sm in self.run_again_shows:
-                if sm in show_map:
-                    rating_keys.extend(show_map[sm])
+                if sm in self.library.show_map:
+                    rating_keys.extend(self.library.show_map[sm])
         if len(rating_keys) > 0:
             for rating_key in rating_keys:
                 try:
@@ -1766,7 +1766,7 @@ class CollectionBuilder:
         if len(self.run_again_movies) > 0:
             logger.info("")
             for missing_id in self.run_again_movies:
-                if missing_id not in movie_map:
+                if missing_id not in self.library.movie_map:
                     try:
                         movie = self.config.TMDb.get_movie(missing_id)
                     except Failed as e:
@@ -1780,7 +1780,7 @@ class CollectionBuilder:
         if len(self.run_again_shows) > 0 and self.library.is_show:
             logger.info("")
             for missing_id in self.run_again_shows:
-                if missing_id not in show_map:
+                if missing_id not in self.library.show_map:
                     try:
                         title = str(self.config.TVDb.get_series(self.library.Plex.language, missing_id).title.encode("ascii", "replace").decode())
                     except Failed as e:

modules/config.py

@@ -446,7 +446,7 @@ class Config:
                 params["plex"]["clean_bundles"] = check_for_attribute(lib, "clean_bundles", parent="plex", var_type="bool", default=self.general["plex"]["clean_bundles"], save=False)
                 params["plex"]["empty_trash"] = check_for_attribute(lib, "empty_trash", parent="plex", var_type="bool", default=self.general["plex"]["empty_trash"], save=False)
                 params["plex"]["optimize"] = check_for_attribute(lib, "optimize", parent="plex", var_type="bool", default=self.general["plex"]["optimize"], save=False)
-                library = PlexAPI(params, self.TMDb, self.TVDb)
+                library = PlexAPI(params)
                 logger.info("")
                 logger.info(f"{display_name} Library Connection Successful")
             except Failed as e:

modules/plex.py

@@ -275,7 +275,7 @@ smart_types = {
 }
 
 class PlexAPI:
-    def __init__(self, params, TMDb, TVDb):
+    def __init__(self, params):
         try:
             self.PlexServer = PlexServer(params["plex"]["url"], params["plex"]["token"], timeout=params["plex"]["timeout"])
         except Unauthorized:
@@ -318,8 +318,6 @@ class PlexAPI:
             for ad in params["asset_directory"]:
                 logger.info(f"Using Asset Directory: {ad}")
 
-        self.TMDb = TMDb
-        self.TVDb = TVDb
         self.Radarr = None
         self.Sonarr = None
         self.Tautulli = None
@@ -351,6 +349,10 @@ class PlexAPI:
         self.empty_trash = params["plex"]["empty_trash"]
         self.optimize = params["plex"]["optimize"]
         self.missing = {}
+        self.movie_map = {}
+        self.show_map = {}
+        self.movie_rating_key_map = {}
+        self.show_rating_key_map = {}
         self.run_again = []
 
     def get_all_collections(self):
@@ -664,6 +666,42 @@ class PlexAPI:
         name = collection.title if isinstance(collection, Collections) else str(collection)
         return name, self.get_collection_items(collection, smart_label_collection)
 
+    def map_guids(self, config):
+        logger.info(f"Loading {'Movie' if self.is_movie else 'Show'} Library: {self.name}")
+        logger.info("")
+        items = self.Plex.all()
+        logger.info(f"Mapping {'Movie' if self.is_movie else 'Show'} Library: {self.name}")
+        logger.info("")
+        for i, item in enumerate(items, 1):
+            util.print_return(f"Processing: {i}/{len(items)} {item.title}")
+            if item.ratingKey not in self.movie_rating_key_map and item.ratingKey not in self.show_rating_key_map:
+                id_type, main_id = config.Convert.get_id(item, self)
+                if main_id:
+                    if not isinstance(main_id, list):
+                        main_id = [main_id]
+                    if id_type == "movie":
+                        self.movie_rating_key_map[item.ratingKey] = main_id[0]
+                        for m in main_id:
+                            if m in self.movie_map:
+                                self.movie_map[m].append(item.ratingKey)
+                            else:
+                                self.movie_map[m] = [item.ratingKey]
+                    elif id_type == "show":
+                        self.show_rating_key_map[item.ratingKey] = main_id[0]
+                        for m in main_id:
+                            if m in self.show_map:
+                                self.show_map[m].append(item.ratingKey)
+                            else:
+                                self.show_map[m] = [item.ratingKey]
+        logger.info("")
+        logger.info(util.adjust_space(f"Processed {len(items)} {'Movies' if self.is_movie else 'Shows'}"))
+
+    def get_tmdb_from_map(self, item):
+        return self.movie_rating_key_map[item.ratingKey] if item.ratingKey in self.movie_rating_key_map else None
+
+    def get_tvdb_from_map(self, item):
+        return self.show_rating_key_map[item.ratingKey] if item.ratingKey in self.show_rating_key_map else None
+
     def search_item(self, data, year=None):
         kwargs = {}
         if year is not None:

plex_meta_manager.py

@@ -144,9 +144,9 @@ def update_libraries(config):
         logger.info("")
         util.separator(f"Mapping {library.name} Library", space=False, border=False)
         logger.info("")
-        movie_map, show_map = map_guids(config, library)
+        library.map_guids(config)
         if not config.test_mode and not config.resume_from and not collection_only and library.mass_update:
-            mass_metadata(config, library, movie_map, show_map)
+            mass_metadata(config, library)
         for metadata in library.metadata_files:
             logger.info("")
             util.separator(f"Running Metadata File\n{metadata.path}")
@@ -164,7 +164,7 @@ def update_libraries(config):
                 logger.info("")
                 util.separator(f"{'Test ' if config.test_mode else ''}Collections")
                 logger.removeHandler(library_handler)
-                run_collection(config, library, metadata, collections_to_run, movie_map, show_map)
+                run_collection(config, library, metadata, collections_to_run)
                 logger.addHandler(library_handler)
 
         if not config.test_mode and not config.requested_collections and ((library.show_unmanaged and not library_only) or (library.assets_for_all and not collection_only)):
@@ -221,13 +221,13 @@ def update_libraries(config):
                 logger.info("")
                 util.separator(f"{library.name} Library Run Again")
                 logger.info("")
-                movie_map, show_map = map_guids(config, library)
+                library.map_guids(config)
                 for builder in library.run_again:
                     logger.info("")
                     util.separator(f"{builder.name} Collection")
                     logger.info("")
                     try:
-                        builder.run_collections_again(movie_map, show_map)
+                        builder.run_collections_again()
                     except Failed as e:
                         util.print_stacktrace()
                         util.print_multiline(e, error=True)
@@ -244,33 +244,7 @@ def update_libraries(config):
             if library.optimize:
                 library.query(library.PlexServer.library.optimize)
 
-def map_guids(config, library):
-    movie_map = {}
-    show_map = {}
-    logger.info(f"Loading {'Movie' if library.is_movie else 'Show'} Library: {library.name}")
-    logger.info("")
-    items = library.Plex.all()
-    logger.info(f"Mapping {'Movie' if library.is_movie else 'Show'} Library: {library.name}")
-    logger.info("")
-    for i, item in enumerate(items, 1):
-        util.print_return(f"Processing: {i}/{len(items)} {item.title}")
-        id_type, main_id = config.Convert.get_id(item, library)
-        if main_id:
-            if not isinstance(main_id, list):
-                main_id = [main_id]
-            if id_type == "movie":
-                for m in main_id:
-                    if m in movie_map:              movie_map[m].append(item.ratingKey)
-                    else:                           movie_map[m] = [item.ratingKey]
-            elif id_type == "show":
-                for m in main_id:
-                    if m in show_map:               show_map[m].append(item.ratingKey)
-                    else:                           show_map[m] = [item.ratingKey]
-    logger.info("")
-    logger.info(util.adjust_space(f"Processed {len(items)} {'Movies' if library.is_movie else 'Shows'}"))
-    return movie_map, show_map
-
-def mass_metadata(config, library, movie_map, show_map):
+def mass_metadata(config, library):
     logger.info("")
     util.separator(f"Mass Editing {'Movie' if library.is_movie else 'Show'} Library: {library.name}")
     logger.info("")
@@ -290,15 +264,9 @@ def mass_metadata(config, library, movie_map, show_map):
                 else:
                     tvdb_id = t_id
         if not tmdb_id and not tvdb_id:
-            for tmdb, rating_keys in movie_map.items():
-                if item.ratingKey in rating_keys:
-                    tmdb_id = tmdb
-                    break
+            tmdb_id = library.get_tmdb_from_map(item)
         if not tmdb_id and not tvdb_id and library.is_show:
-            for tvdb, rating_keys in show_map.items():
-                if item.ratingKey in rating_keys:
-                    tvdb_id = tvdb
-                    break
+            tmdb_id = library.get_tvdb_from_map(item)
 
         if library.Radarr and library.radarr_add_all and tmdb_id:
             radarr_adds.append(tmdb_id)
@@ -387,7 +355,7 @@ def mass_metadata(config, library, movie_map, show_map):
         except Failed as e:
             logger.error(e)
 
-def run_collection(config, library, metadata, requested_collections, movie_map, show_map):
+def run_collection(config, library, metadata, requested_collections):
     logger.info("")
     for mapping_name, collection_attrs in requested_collections.items():
         collection_start = datetime.now()
@@ -456,13 +424,13 @@ def run_collection(config, library, metadata, requested_collections, movie_map,
                     for filter_key, filter_value in builder.filters:
                         logger.info(f"Collection Filter {filter_key}: {filter_value}")
 
-                builder.collect_rating_keys(movie_map, show_map)
+                builder.collect_rating_keys()
 
                 if len(builder.rating_keys) > 0 and builder.build_collection:
                     logger.info("")
                     util.separator(f"Adding to {mapping_name} Collection", space=False, border=False)
                     logger.info("")
-                    builder.add_to_collection(movie_map)
+                    builder.add_to_collection()
                 if len(builder.missing_movies) > 0 or len(builder.missing_shows) > 0:
                     logger.info("")
                     util.separator(f"Missing from Library", space=False, border=False)