changed tmdb Requirement module

modules/builder.py

@@ -376,10 +376,10 @@ class CollectionBuilder:
                 for tmdb_id in util.get_int_list(self.data[methods["tmdb_person"]], "TMDb Person ID"):
                     person = self.config.TMDb.get_person(tmdb_id)
                     valid_names.append(person.name)
-                    if hasattr(person, "biography") and person.biography:
+                    if person.biography:
                         self.summaries["tmdb_person"] = person.biography
-                    if hasattr(person, "profile_path") and person.profile_path:
+                    if person.profile_url:
-                        self.posters["tmdb_person"] = f"{self.config.TMDb.image_url}{person.profile_path}"
+                        self.posters["tmdb_person"] = person.profile_url
                 if len(valid_names) > 0:
                     self.details["tmdb_person"] = valid_names
                 else:
@@ -715,11 +715,9 @@ class CollectionBuilder:
         if method_name == "url_poster":
             self.posters[method_name] = method_data
         elif method_name == "tmdb_poster":
-            url_slug = self.config.TMDb.get_movie_show_or_collection(util.regex_first_int(method_data, 'TMDb ID'), self.library.is_movie).poster_path
+            self.posters[method_name] = self.config.TMDb.get_movie_show_or_collection(util.regex_first_int(method_data, 'TMDb ID'), self.library.is_movie).poster_url
-            self.posters[method_name] = f"{self.config.TMDb.image_url}{url_slug}"
         elif method_name == "tmdb_profile":
-            url_slug = self.config.TMDb.get_person(util.regex_first_int(method_data, 'TMDb Person ID')).profile_path
+            self.posters[method_name] = self.config.TMDb.get_person(util.regex_first_int(method_data, 'TMDb Person ID')).profile_url
-            self.posters[method_name] = f"{self.config.TMDb.image_url}{url_slug}"
         elif method_name == "tvdb_poster":
             self.posters[method_name] = f"{self.config.TVDb.get_item(method_data, self.library.is_movie).poster_path}"
         elif method_name == "file_poster":
@@ -732,8 +730,7 @@ class CollectionBuilder:
         if method_name == "url_background":
             self.backgrounds[method_name] = method_data
         elif method_name == "tmdb_background":
-            url_slug = self.config.TMDb.get_movie_show_or_collection(util.regex_first_int(method_data, 'TMDb ID'), self.library.is_movie).poster_path
+            self.backgrounds[method_name] = self.config.TMDb.get_movie_show_or_collection(util.regex_first_int(method_data, 'TMDb ID'), self.library.is_movie).backdrop_url
-            self.backgrounds[method_name] = f"{self.config.TMDb.image_url}{url_slug}"
         elif method_name == "tvdb_background":
             self.posters[method_name] = f"{self.config.TVDb.get_item(method_data, self.library.is_movie).background_path}"
         elif method_name == "file_background":
@@ -1160,21 +1157,21 @@ class CollectionBuilder:
             if method_name.endswith("_details"):
                 if method_name.startswith(("tmdb_collection", "tmdb_movie", "tmdb_show")):
                     item = self.config.TMDb.get_movie_show_or_collection(values[0], self.library.is_movie)
-                    if hasattr(item, "overview") and item.overview:
+                    if item.overview:
                         self.summaries[method_name] = item.overview
-                    if hasattr(item, "backdrop_path") and item.backdrop_path:
+                    if item.backdrop_url:
-                        self.backgrounds[method_name] = f"{self.config.TMDb.image_url}{item.backdrop_path}"
+                        self.backgrounds[method_name] = item.backdrop_url
-                    if hasattr(item, "poster_path") and item.poster_path:
+                    if item.poster_path:
-                        self.posters[method_name] = f"{self.config.TMDb.image_url}{item.poster_path}"
+                        self.posters[method_name] = item.poster_url
                 elif method_name.startswith(("tmdb_actor", "tmdb_crew", "tmdb_director", "tmdb_producer", "tmdb_writer")):
                     item = self.config.TMDb.get_person(values[0])
-                    if hasattr(item, "biography") and item.biography:
+                    if item.biography:
                         self.summaries[method_name] = item.biography
-                    if hasattr(item, "profile_path") and item.profile_path:
+                    if item.profile_path:
-                        self.posters[method_name] = f"{self.config.TMDb.image_url}{item.profile_path}"
+                        self.posters[method_name] = item.profile_url
                 elif method_name.startswith("tmdb_list"):
                     item = self.config.TMDb.get_list(values[0])
-                    if hasattr(item, "description") and item.description:
+                    if item.description:
                         self.summaries[method_name] = item.description
             for value in values:
                 self.builders.append((method_name[:-8] if method_name.endswith("_details") else method_name, value))
@@ -1202,12 +1199,10 @@ class CollectionBuilder:
         if method_name.endswith("_details"):
             if method_name.startswith(("tvdb_movie", "tvdb_show")):
                 item = self.config.TVDb.get_item(values[0], method_name.startswith("tvdb_movie"))
-                if hasattr(item, "description") and item.description:
+                if item.background_path:
-                    self.summaries[method_name] = item.description
+                    self.backgrounds[method_name] = item.background_path
-                if hasattr(item, "background_path") and item.background_path:
+                if item.poster_path:
-                    self.backgrounds[method_name] = f"{self.config.TMDb.image_url}{item.background_path}"
+                    self.posters[method_name] = item.poster_path
-                if hasattr(item, "poster_path") and item.poster_path:
-                    self.posters[method_name] = f"{self.config.TMDb.image_url}{item.poster_path}"
             elif method_name.startswith("tvdb_list"):
                 self.summaries[method_name] = self.config.TVDb.get_list_description(values[0])
         for value in values:
@@ -1779,20 +1774,21 @@ class CollectionBuilder:
                 if item is None:
                     item = self.config.TMDb.get_movie(item_id) if is_movie else self.config.TMDb.get_show(self.config.Convert.tvdb_to_tmdb(item_id))
                 if check_released:
-                    if util.validate_date(item.release_date if is_movie else item.first_air_date, "") > self.current_time:
+                    date_to_check = item.release_date if is_movie else item.first_air_date
+                    if date_to_check > self.current_time:
                         return False
                 for filter_method, filter_data in self.tmdb_filters:
                     filter_attr, modifier, filter_final = self._split(filter_method)
                     if filter_attr == "original_language":
-                        if (modifier == ".not" and item.original_language in filter_data) \
+                        if (modifier == ".not" and item.original_language.iso_639_1 in filter_data) \
-                                or (modifier == "" and item.original_language not in filter_data):
+                                or (modifier == "" and item.original_language.iso_639_1 not in filter_data):
                             return False
                     elif filter_attr in ["first_episode_aired", "last_episode_aired"]:
                         tmdb_date = None
                         if filter_attr == "first_episode_aired":
-                            tmdb_date = util.validate_date(item.first_air_date, "TMDB First Air Date")
+                            tmdb_date = item.first_air_date
                         elif filter_attr == "last_episode_aired":
-                            tmdb_date = util.validate_date(item.last_air_date, "TMDB Last Air Date")
+                            tmdb_date = item.last_air_date
                         if util.is_date_filter(tmdb_date, modifier, filter_data, filter_final, self.current_time):
                             return False
                     elif modifier in [".gt", ".gte", ".lt", ".lte"]:
@@ -1801,10 +1797,8 @@ class CollectionBuilder:
                             attr = item.vote_count
                         elif filter_attr == "tmdb_year" and is_movie:
                             attr = item.year
-                        elif filter_attr == "tmdb_year" and not is_movie:
+                        elif filter_attr == "tmdb_year" and not is_movie and item.first_air_date:
-                            air_date = item.first_air_date
+                            attr = item.first_air_date.year
-                            if air_date:
-                                attr = util.validate_date(air_date, "TMDb Year Filter").year
                         if util.is_number_filter(attr, modifier, filter_data):
                             return False
             except Failed:
@@ -1940,7 +1934,7 @@ class CollectionBuilder:
                 except Failed as e:
                     logger.error(e)
                     continue
-                current_title = f"{movie.title} ({util.validate_date(movie.release_date, 'test').year})" if movie.release_date else movie.title
+                current_title = f"{movie.title} ({movie.release_date.year})" if movie.release_date else movie.title
                 if self.check_tmdb_filter(missing_id, True, item=movie, check_released=self.details["missing_only_released"]):
                     missing_movies_with_names.append((current_title, missing_id))
                     if self.details["show_missing"] is True:
@@ -2090,10 +2084,10 @@ class CollectionBuilder:
             if "item_tmdb_season_titles" in self.item_details and item.ratingKey in self.library.show_rating_key_map:
                 try:
                     tmdb_id = self.config.Convert.tvdb_to_tmdb(self.library.show_rating_key_map[item.ratingKey])
-                    names = {str(s.season_number): s.name for s in self.config.TMDb.get_show(tmdb_id).seasons}
+                    names = {s.season_number: s.name for s in self.config.TMDb.get_show(tmdb_id).seasons}
                     for season in self.library.query(item.seasons):
-                        if str(season.index) in names:
+                        if season.index in names:
-                            self.library.edit_query(season, {"title.locked": 1, "title.value": names[str(season.index)]})
+                            self.library.edit_query(season, {"title.locked": 1, "title.value": names[season.index]})
                 except Failed as e:
                     logger.error(e)
 
@@ -2452,7 +2446,7 @@ class CollectionBuilder:
                         logger.error(e)
                         continue
                     if self.details["show_missing"] is True:
-                        current_title = f"{movie.title} ({util.validate_date(movie.release_date, 'test').year})" if movie.release_date else movie.title
+                        current_title = f"{movie.title} ({movie.release_date.year})" if movie.release_date else movie.title
                         logger.info(f"{name} {self.Type} | ? | {current_title} (TMDb: {missing_id})")
             logger.info("")
             logger.info(f"{len(self.run_again_movies)} Movie{'s' if len(self.run_again_movies) > 1 else ''} Missing")

modules/meta.py

@@ -231,7 +231,7 @@ class MetadataFile(DataFile):
             self.templates = get_dict("templates", data)
             self.collections = get_dict("collections", data, library.collections)
 
-            if self.metadata is None and self.collections is None:
+            if not self.metadata and not self.collections:
                 raise Failed("YAML Error: metadata or collections attribute is required")
             logger.info(f"Metadata File Loaded Successfully")
 
@@ -423,15 +423,15 @@ class MetadataFile(DataFile):
             summary = None
             genres = []
             if tmdb_item:
-                originally_available = tmdb_item.release_date if tmdb_is_movie else tmdb_item.first_air_date
+                originally_available = datetime.strftime(tmdb_item.release_date if tmdb_is_movie else tmdb_item.first_air_date, "%Y-%m-%d")
-                if tmdb_item and tmdb_is_movie is True and tmdb_item.original_title != tmdb_item.title:
+                if tmdb_is_movie 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:
+                elif not tmdb_is_movie 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:
+                if tmdb_is_movie and tmdb_item.production_companies:
                     studio = tmdb_item.production_companies[0].name
-                elif tmdb_is_movie is False and tmdb_item.networks:
+                elif not tmdb_is_movie 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

modules/tmdb.py

@@ -1,8 +1,7 @@
-import logging, tmdbv3api
+import logging
 from modules import util
 from modules.util import Failed
-from retrying import retry
+from tmdbapis import TMDbAPIs, TMDbException
-from tmdbv3api.exceptions import TMDbException
 
 logger = logging.getLogger("Plex Meta Manager")
 
@@ -62,59 +61,35 @@ discover_monetization_types = ["flatrate", "free", "ads", "rent", "buy"]
 class TMDb:
     def __init__(self, config, params):
         self.config = config
-        self.TMDb = tmdbv3api.TMDb(session=self.config.session)
+        self.apikey = params["apikey"]
-        self.TMDb.api_key = params["apikey"]
+        self.language = params["language"]
-        self.TMDb.language = params["language"]
         try:
-            response = tmdbv3api.Configuration().info()
+            self.TMDb = TMDbAPIs(self.apikey, language=self.language, session=self.config.session)
-            if hasattr(response, "status_message"):
-                raise Failed(f"TMDb Error: {response.status_message}")
         except TMDbException as e:
             raise Failed(f"TMDb Error: {e}")
-        self.apikey = params["apikey"]
-        self.language = params["language"]
-        self.Movie = tmdbv3api.Movie()
-        self.TV = tmdbv3api.TV()
-        self.Discover = tmdbv3api.Discover()
-        self.Trending = tmdbv3api.Trending()
-        self.Keyword = tmdbv3api.Keyword()
-        self.List = tmdbv3api.List()
-        self.Company = tmdbv3api.Company()
-        self.Network = tmdbv3api.Network()
-        self.Collection = tmdbv3api.Collection()
-        self.Person = tmdbv3api.Person()
-        self.image_url = "https://image.tmdb.org/t/p/original"
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def convert_from(self, tmdb_id, convert_to, is_movie):
-        try:
+        item = self.get_movie(tmdb_id) if is_movie else self.get_show(tmdb_id)
-            id_to_return = self.Movie.external_ids(tmdb_id)[convert_to] if is_movie else self.TV.external_ids(tmdb_id)[convert_to]
+        check_id = item.tvdb_id if convert_to == "tvdb_id" and not is_movie else item.imdb_id
-            if not id_to_return or (convert_to == "tvdb_id" and id_to_return == 0):
+        if not check_id:
-                raise Failed(f"TMDb Error: No {convert_to.upper().replace('B_', 'b ')} found for TMDb ID {tmdb_id}")
+            raise Failed(f"TMDb Error: No {convert_to.upper().replace('B_', 'b ')} found for TMDb ID {tmdb_id}")
-            return id_to_return if convert_to == "imdb_id" else int(id_to_return)
+        return check_id
-        except TMDbException:
-            raise Failed(f"TMDb Error: TMDb {'Movie' if is_movie else 'Show'} ID: {tmdb_id} not found")
-
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
-    def convert_to(self, external_id, external_source):
-        return self.Movie.external(external_id=external_id, external_source=external_source)
 
     def convert_tvdb_to(self, tvdb_id):
-        search = self.convert_to(tvdb_id, "tvdb_id")
+        results = self.TMDb.find_by_id(tvdb_id=tvdb_id)
-        if len(search["tv_results"]) == 1:
+        if not results.tv_results:
-            return int(search["tv_results"][0]["id"])
-        else:
             raise Failed(f"TMDb Error: No TMDb ID found for TVDb ID {tvdb_id}")
+        return results.tv_results[0].id
 
     def convert_imdb_to(self, imdb_id):
-        search = self.convert_to(imdb_id, "imdb_id")
+        results = self.TMDb.find_by_id(imdb_id=imdb_id)
-        if len(search["movie_results"]) > 0:
+        if results.movie_results:
-            return int(search["movie_results"][0]["id"]), "movie"
+            return results.movie_results[0].id, "movie"
-        elif len(search["tv_results"]) > 0:
+        elif results.tv_results:
-            return int(search["tv_results"][0]["id"]), "show"
+            return results.tv_results[0].id, "show"
-        elif len(search["tv_episode_results"]) > 0:
+        elif results.tv_episode_results:
-            item = search['tv_episode_results'][0]
+            item = results.tv_episode_results[0]
-            return f"{item['show_id']}_{item['season_number']}_{item['episode_number']}", "episode"
+            return f"{item.tv_id}_{item.season_number}_{item.episode_number}", "episode"
         else:
             raise Failed(f"TMDb Error: No TMDb ID found for IMDb ID {imdb_id}")
 
@@ -126,112 +101,38 @@ class TMDb:
                 except Failed:                  raise Failed(f"TMDb Error: No Movie or Collection found for TMDb ID {tmdb_id}")
         else:                           return self.get_show(tmdb_id)
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def get_movie(self, tmdb_id):
-        try:                            return self.Movie.details(tmdb_id)
+        try:                            return self.TMDb.movie(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Movie found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def get_show(self, tmdb_id):
-        try:                            return self.TV.details(tmdb_id)
+        try:                            return self.TMDb.tv_show(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Show found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def get_collection(self, tmdb_id):
-        try:                            return self.Collection.details(tmdb_id)
+        try:                            return self.TMDb.collection(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Collection found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def get_person(self, tmdb_id):
-        try:                            return self.Person.details(tmdb_id)
+        try:                            return self.TMDb.person(tmdb_id)
-        except TMDbException as e:      raise Failed(f"TMDb Error: No Person found for TMDb ID {tmdb_id}: {e}")
-
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
-    def _person_credits(self, tmdb_id):
-        try:                            return self.Person.combined_credits(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Person found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def _company(self, tmdb_id):
-        try:                            return self.Company.details(tmdb_id)
+        try:                            return self.TMDb.company(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Company found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def _network(self, tmdb_id):
-        try:                            return self.Network.details(tmdb_id)
+        try:                            return self.TMDb.network(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Network found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def _keyword(self, tmdb_id):
-        try:                            return self.Keyword.details(tmdb_id)
+        try:                            return self.TMDb.keyword(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No Keyword found for TMDb ID {tmdb_id}: {e}")
 
-    @retry(stop_max_attempt_number=6, wait_fixed=10000, retry_on_exception=util.retry_if_not_failed)
     def get_list(self, tmdb_id):
-        try:                            return self.List.details(tmdb_id, all_details=True)
+        try:                            return self.TMDb.list(tmdb_id)
         except TMDbException as e:      raise Failed(f"TMDb Error: No List found for TMDb ID {tmdb_id}: {e}")
 
-    def _credits(self, tmdb_id, actor=False, crew=False, director=False, producer=False, writer=False):
-        ids = []
-        actor_credits = self._person_credits(tmdb_id)
-        if actor:
-            for credit in actor_credits.cast:
-                if credit.media_type == "movie":
-                    ids.append((credit.id, "tmdb"))
-                elif credit.media_type == "tv":
-                    ids.append((credit.id, "tmdb_show"))
-        for credit in actor_credits.crew:
-            if crew or \
-                    (director and credit.department == "Directing") or  \
-                    (producer and credit.department == "Production") or \
-                    (writer and credit.department == "Writing"):
-                if credit.media_type == "movie":
-                    ids.append((credit.id, "tmdb"))
-                elif credit.media_type == "tv":
-                    ids.append((credit.id, "tmdb_show"))
-        return ids
-
-    def _pagenation(self, method, amount, is_movie):
-        ids = []
-        for x in range(int(amount / 20) + 1):
-            if method == "tmdb_popular":                        tmdb_items = self.Movie.popular(x + 1) if is_movie else self.TV.popular(x + 1)
-            elif method == "tmdb_top_rated":                    tmdb_items = self.Movie.top_rated(x + 1) if is_movie else self.TV.top_rated(x + 1)
-            elif method == "tmdb_now_playing" and is_movie:     tmdb_items = self.Movie.now_playing(x + 1)
-            elif method == "tmdb_trending_daily":               tmdb_items = self.Trending.movie_day(x + 1) if is_movie else self.Trending.tv_day(x + 1)
-            elif method == "tmdb_trending_weekly":              tmdb_items = self.Trending.movie_week(x + 1) if is_movie else self.Trending.tv_week(x + 1)
-            else:                                               raise Failed(f"TMDb Error: {method} method not supported")
-            for tmdb_item in tmdb_items:
-                try:
-                    ids.append((tmdb_item.id, "tmdb" if is_movie else "tmdb_show"))
-                except Failed as e:
-                    logger.error(e)
-                if len(ids) == amount: break
-            if len(ids) == amount: break
-        return ids
-
-    def _discover(self, attrs, amount, is_movie):
-        ids = []
-        for date_attr in discover_dates:
-            if date_attr in attrs:
-                attrs[date_attr] = util.validate_date(attrs[date_attr], f"tmdb_discover attribute {date_attr}", return_as="%Y-%m-%d")
-        if self.config.trace_mode:
-            logger.debug(f"Params: {attrs}")
-        self.Discover.discover_movies(attrs) if is_movie else self.Discover.discover_tv_shows(attrs)
-        total_pages = int(self.TMDb.total_pages)
-        total_results = int(self.TMDb.total_results)
-        amount = total_results if amount == 0 or total_results < amount else amount
-        for x in range(total_pages):
-            attrs["page"] = x + 1
-            tmdb_items = self.Discover.discover_movies(attrs) if is_movie else self.Discover.discover_tv_shows(attrs)
-            for tmdb_item in tmdb_items:
-                try:
-                    ids.append((tmdb_item.id, "tmdb" if is_movie else "tmdb_show"))
-                except Failed as e:
-                    logger.error(e)
-                if len(ids) == amount: break
-            if len(ids) == amount: break
-        return ids, amount
-
     def validate_tmdb_ids(self, tmdb_ids, tmdb_method):
         tmdb_list = util.get_int_list(tmdb_ids, f"TMDb {type_map[tmdb_method]} ID")
         tmdb_values = []
@@ -249,74 +150,86 @@ class TMDb:
         elif tmdb_type == "Person":                 self.get_person(tmdb_id)
         elif tmdb_type == "Company":                self._company(tmdb_id)
         elif tmdb_type == "Network":                self._network(tmdb_id)
+        elif tmdb_type == "Keyword":                self._keyword(tmdb_id)
         elif tmdb_type == "List":                   self.get_list(tmdb_id)
         return tmdb_id
 
     def get_tmdb_ids(self, method, data, is_movie):
         pretty = method.replace("_", " ").title().replace("Tmdb", "TMDb")
         media_type = "Movie" if is_movie else "Show"
+        result_type = "tmdb" if is_movie else "tmdb_show"
         ids = []
-        if method in ["tmdb_discover", "tmdb_company", "tmdb_keyword"] or (method == "tmdb_network" and not is_movie):
+        if method in ["tmdb_network", "tmdb_company", "tmdb_keyword"]:
-            attrs = None
+            if method == "tmdb_company":
-            tmdb_id = ""
+                item = self._company(int(data))
-            tmdb_name = ""
+            elif method == "tmdb_network":
-            if method in ["tmdb_company", "tmdb_network", "tmdb_keyword"]:
+                item = self._network(int(data))
-                tmdb_id = int(data)
-                if method == "tmdb_company":
-                    tmdb_name = str(self._company(tmdb_id).name)
-                    attrs = {"with_companies": tmdb_id}
-                elif method == "tmdb_network":
-                    tmdb_name = str(self._network(tmdb_id).name)
-                    attrs = {"with_networks": tmdb_id}
-                elif method == "tmdb_keyword":
-                    tmdb_name = str(self._keyword(tmdb_id).name)
-                    attrs = {"with_keywords": tmdb_id}
-                limit = 0
             else:
-                attrs = data.copy()
+                item = self._keyword(int(data))
-                limit = int(attrs.pop("limit"))
+            results = item.movies if is_movie else item.tv_shows
-            ids, amount = self._discover(attrs, limit, is_movie)
+            ids = [(i.id, result_type) for i in results.get_results(results.total_results)]
-            if method in ["tmdb_company", "tmdb_network", "tmdb_keyword"]:
+            logger.info(f"Processing {pretty}: ({data}) {item.name} ({len(results)} {media_type}{'' if len(results) == 1 else 's'})")
-                logger.info(f"Processing {pretty}: ({tmdb_id}) {tmdb_name} ({amount} {media_type}{'' if amount == 1 else 's'})")
+        elif method == "tmdb_discover":
-            elif method == "tmdb_discover":
+            attrs = data.copy()
-                logger.info(f"Processing {pretty}: {amount} {media_type}{'' if amount == 1 else 's'}")
+            limit = int(attrs.pop("limit"))
-                for attr, value in attrs.items():
+            for date_attr in discover_dates:
-                    logger.info(f"           {attr}: {value}")
+                if date_attr in attrs:
+                    attrs[date_attr] = util.validate_date(attrs[date_attr], f"tmdb_discover attribute {date_attr}", return_as="%Y-%m-%d")
+            if self.config.trace_mode:
+                logger.debug(f"Params: {attrs}")
+            results = self.TMDb.discover_movies(**attrs) if is_movie else self.TMDb.discover_tv_shows(**attrs)
+            amount = results.total_results if limit == 0 or results.total_results < limit else limit
+            ids = [(i.id, result_type) for i in results.get_results(amount)]
+            logger.info(f"Processing {pretty}: {amount} {media_type}{'' if amount == 1 else 's'}")
+            for attr, value in attrs.items():
+                logger.info(f"           {attr}: {value}")
         elif method in ["tmdb_popular", "tmdb_top_rated", "tmdb_now_playing", "tmdb_trending_daily", "tmdb_trending_weekly"]:
-            ids = self._pagenation(method, data, is_movie)
+            if method == "tmdb_popular":
+                results = self.TMDb.popular_movies() if is_movie else self.TMDb.popular_tv()
+            elif method == "tmdb_top_rated":
+                results = self.TMDb.top_rated_movies() if is_movie else self.TMDb.top_rated_tv()
+            elif method == "tmdb_now_playing":
+                results = self.TMDb.now_playing_movies()
+            else:
+                results = self.TMDb.trending("movie" if is_movie else "tv", "day" if method == "tmdb_trending_daily" else "week")
+            ids = [(i.id, result_type) for i in results.get_results(data)]
             logger.info(f"Processing {pretty}: {data} {media_type}{'' if data == 1 else 's'}")
         else:
             tmdb_id = int(data)
             if method == "tmdb_list":
-                tmdb_list = self.get_list(tmdb_id)
+                results = self.get_list(tmdb_id)
-                tmdb_name = tmdb_list.name
+                tmdb_name = results.name
-                for tmdb_item in tmdb_list.items:
+                ids = [(i.id, result_type) for i in results.get_results(results.total_results)]
-                    if tmdb_item.media_type == "movie":
-                        ids.append((tmdb_item.id, "tmdb"))
-                    elif tmdb_item.media_type == "tv":
-                        try:
-                            ids.append((tmdb_item.id, "tmdb_show"))
-                        except Failed:
-                            pass
             elif method == "tmdb_movie":
-                tmdb_name = str(self.get_movie(tmdb_id).title)
+                tmdb_name = self.get_movie(tmdb_id).title
                 ids.append((tmdb_id, "tmdb"))
             elif method == "tmdb_collection":
-                tmdb_items = self.get_collection(tmdb_id)
+                collection = self.get_collection(tmdb_id)
-                tmdb_name = str(tmdb_items.name)
+                tmdb_name = collection.name
-                for tmdb_item in tmdb_items.parts:
+                ids = [(t.id, "tmdb") for t in collection.movies]
-                    ids.append((tmdb_item["id"], "tmdb"))
             elif method == "tmdb_show":
-                tmdb_name = str(self.get_show(tmdb_id).name)
+                tmdb_name = self.get_show(tmdb_id).name
                 ids.append((tmdb_id, "tmdb_show"))
             else:
-                tmdb_name = str(self.get_person(tmdb_id).name)
+                person = self.get_person(tmdb_id)
-                if method == "tmdb_actor":                  ids = self._credits(tmdb_id, actor=True)
+                tmdb_name = person.name
-                elif method == "tmdb_director":             ids = self._credits(tmdb_id, director=True)
+                if method == "tmdb_actor":
-                elif method == "tmdb_producer":             ids = self._credits(tmdb_id, producer=True)
+                    ids = [(i.id, "tmdb") for i in person.movie_cast]
-                elif method == "tmdb_writer":               ids = self._credits(tmdb_id, writer=True)
+                    ids.extend([(i.id, "tmdb_show") for i in person.tv_cast])
-                elif method == "tmdb_crew":                 ids = self._credits(tmdb_id, crew=True)
+                elif method == "tmdb_crew":
-                else:                                       raise Failed(f"TMDb Error: Method {method} not supported")
+                    ids = [(i.id, "tmdb") for i in person.movie_crew]
+                    ids.extend([(i.id, "tmdb_show") for i in person.tv_crew])
+                elif method == "tmdb_director":
+                    ids = [(i.id, "tmdb") for i in person.movie_crew if i.department == "Directing"]
+                    ids.extend([(i.id, "tmdb_show") for i in person.tv_crew])
+                elif method == "tmdb_writer":
+                    ids = [(i.id, "tmdb") for i in person.movie_crew if i.department == "Writing"]
+                    ids.extend([(i.id, "tmdb_show") for i in person.tv_crew])
+                elif method == "tmdb_producer":
+                    ids = [(i.id, "tmdb") for i in person.movie_crew if i.department == "Production"]
+                    ids.extend([(i.id, "tmdb_show") for i in person.tv_crew])
+                else:
+                    raise Failed(f"TMDb Error: Method {method} not supported")
             if len(ids) > 0:
                 logger.info(f"Processing {pretty}: ({tmdb_id}) {tmdb_name} ({len(ids)} Item{'' if len(ids) == 1 else 's'})")
         return ids

plex_meta_manager.py

@@ -544,8 +544,8 @@ def library_operations(config, library):
                 else:
                     logger.info(util.adjust_space(f"{item.title[:25]:<25} | No TVDb ID for Guid: {item.guid}"))
 
-            if library.tmdb_collections and tmdb_item and tmdb_item.belongs_to_collection:
+            if library.tmdb_collections and tmdb_item and tmdb_item.collection:
-                tmdb_collections[tmdb_item.belongs_to_collection.id] = tmdb_item.belongs_to_collection.name
+                tmdb_collections[tmdb_item.collection.id] = tmdb_item.collection.name
 
             if library.mass_genre_update:
                 try:

requirements.txt

@@ -1,5 +1,5 @@
 PlexAPI==4.8.0
-tmdbv3api==1.7.6
+tmdbapis==0.1.4
 arrapi==1.3.0
 lxml==4.7.1
 requests==2.27.1