Update to coding and more error handling on playlist management

Author: brikim

api/emby.py

@@ -241,26 +241,35 @@ def get_playlist_items(self, playlist_id: str) -> EmbyPlaylist:
 
         return None
 
-    def add_playlist_items(self, playlist_id: str, item_ids: list[str]):
+    def add_playlist_items(self, playlist_id: str, item_ids: list[str]) -> bool:
         try:
             headers = {'accept': 'application/json'}
             embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items' + '?Ids=' + self.__get_comma_separated_list(item_ids) + '&api_key=' + self.api_key
             r = requests.post(embyUrl, headers=headers)
+            if r.status_code < 300:
+                return True
         except Exception as e:
             self.logger.error("{} add_playlist_items {} {} error {}".format(self.log_header, utils.get_tag('playlist_id', playlist_id), utils.get_tag('item_ids', item_ids), utils.get_tag('error', e)))
+        return False
 
-    def remove_playlist_items(self, playlist_id: str, playlist_item_ids: list[str]):
+    def remove_playlist_items(self, playlist_id: str, playlist_item_ids: list[str]) -> bool:
         try:
             headers = {'accept': 'application/json'}
             embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items/Delete' + '?EntryIds=' + self.__get_comma_separated_list(playlist_item_ids) + '&api_key=' + self.api_key
             r = requests.post(embyUrl, headers=headers)
+            if r.status_code < 300:
+                return True
         except Exception as e:
             self.logger.error("{} remove_playlist_item {} {} error {}".format(self.log_header, utils.get_tag('playlist_id', playlist_id), utils.get_tag('playlist_item_ids', playlist_item_ids), utils.get_tag('error', e)))
+        return False
 
-    def set_move_playlist_item_to_index(self, playlist_id: str, playlist_item_id: str, index: int):
+    def set_move_playlist_item_to_index(self, playlist_id: str, playlist_item_id: str, index: int) -> bool:
         try:
             headers = {'accept': 'application/json'}
             embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items/' + playlist_item_id + '/Move/' + str(index) + '?api_key=' + self.api_key
             r = requests.post(embyUrl, headers=headers)
+            if r.status_code < 300:
+                return True
         except Exception as e:
-            self.logger.error("{} set_move_playlist_item_to_index {} {} {} error {}".format(self.log_header, utils.get_tag('playlist_id', playlist_id), utils.get_tag('playlist_item_id', playlist_item_id), utils.get_tag('move_index', index), utils.get_tag('error', e)))
+            self.logger.error("{} set_move_playlist_item_to_index {} {} {} error {}".format(self.log_header, utils.get_tag('playlist_id', playlist_id), utils.get_tag('playlist_item_id', playlist_item_id), utils.get_tag('move_index', index), utils.get_tag('error', e)))
+        return False

app.py

@@ -2,7 +2,7 @@
 Media Utilities
 """
 
-version = 'v2.2.2'
+version = 'v2.2.3'
 
 import sys
 import os

service/DeleteWatched.py

@@ -84,7 +84,7 @@ def __init__(self, ansi_code: str, plex_api: PlexAPI, tautulli_api: TautulliAPI,
                 plex_library_name: str = ''
                 plex_media_path: str = ''
                 if 'plex_library_name' in library and 'plex_media_path' in library:
-                    if plex_users_defined == True:
+                    if plex_users_defined is True:
                         plex_library_name = library['plex_library_name']
                         plex_media_path = library['plex_media_path']
                     else:
@@ -93,7 +93,7 @@ def __init__(self, ansi_code: str, plex_api: PlexAPI, tautulli_api: TautulliAPI,
                 emby_library_name = ''
                 emby_media_path = ''
                 if 'emby_library_name' in library and 'emby_media_path' in library:
-                    if emby_users_defined == True:
+                    if emby_users_defined is True:
                         emby_library_name = library['emby_library_name']
                         emby_media_path = library['emby_media_path']
                     else:
@@ -108,7 +108,7 @@ def __init__(self, ansi_code: str, plex_api: PlexAPI, tautulli_api: TautulliAPI,
             self.log_error('Read config {}'.format(utils.get_tag('error', e)))
 
     def hours_since_play(self, use_utc_time: bool, play_date_time: datetime) -> int:
-        current_date_time = datetime.now(timezone.utc) if use_utc_time == True else datetime.now()
+        current_date_time = datetime.now(timezone.utc) if use_utc_time is True else datetime.now()
         time_difference = current_date_time - play_date_time
         return (time_difference.days * 24) + (time_difference.seconds / 3600)
 
@@ -146,7 +146,7 @@ def __find_emby_watched_media(self, lib: LibraryInfo, user_list: List[UserInfo])
                                 item_id = item['EpisodeId']
                             else:
                                 item_id = item['NowPlayingItemId']
-                            if self.emby_api.get_watched_status(user.emby_user_id, item_id) == True:
+                            if self.emby_api.get_watched_status(user.emby_user_id, item_id) is True:
                                 item_hours_since_play = self.hours_since_play(True, datetime.fromisoformat(item['ActivityDateInserted']))
                                 if item_hours_since_play >= self.delete_time_hours:
                                     emby_item = self.emby_api.search_item(item_id)
@@ -166,7 +166,7 @@ def __get_libraries(self) -> List[LibraryInfo]:
             plex_library_name: str = ''
             plex_library_id: str = ''
             if library_config.plex_library_name != '':
-                if self.tautulli_api.get_valid() == True:
+                if self.tautulli_api.get_valid() is True:
                     library_id = self.tautulli_api.get_library_id(library_config.plex_library_name)
                     if library_id != self.tautulli_api.get_invalid_item():
                         plex_library_name = library_config.plex_library_name
@@ -179,7 +179,7 @@ def __get_libraries(self) -> List[LibraryInfo]:
             emby_library_name: str = ''
             emby_library_id: str = ''
             if library_config.emby_library_name != '':
-                if self.jellystat_api.get_valid() == True:
+                if self.jellystat_api.get_valid() is True:
                     library_id = self.jellystat_api.get_library_id(library_config.emby_library_name)
                     if library_id != self.jellystat_api.get_invalid_type():
                         emby_library_name = library_config.emby_library_name
@@ -205,7 +205,7 @@ def __get_user_list(self) -> List[UserInfo]:
             if user_config.plex_user_name != '':
                 plex_api_valid = self.plex_api.get_valid()
                 tautulli_api_valid = self.tautulli_api.get_valid()
-                if plex_api_valid == True and tautulli_api_valid == True:
+                if plex_api_valid is True and tautulli_api_valid is True:
                     plex_user_info = self.tautulli_api.get_user_info(user_config.plex_user_name)
                     if plex_user_info != self.tautulli_api.get_invalid_item():
                         plex_user_name = user_config.plex_user_name
@@ -217,27 +217,27 @@ def __get_user_list(self) -> List[UserInfo]:
                     else:
                         self.log_warning('{} could not find {}'.format(utils.get_formatted_tautulli(), utils.get_tag('user', user_config.plex_user_name)))
                 else:
-                    if plex_api_valid == False:
+                    if plex_api_valid is False:
                         self.log_warning(self.plex_api.get_connection_error_log())
-                    if tautulli_api_valid == False:
+                    if tautulli_api_valid is False:
                         self.log_warning(self.tautulli_api.get_connection_error_log())
 
             emby_user_name = ''
             emby_user_id = ''
             if user_config.emby_user_name != '':
                 emby_api_valid = self.emby_api.get_valid()
                 jellystat_api_valid = self.jellystat_api.get_valid()
-                if emby_api_valid == True and jellystat_api_valid == True:
+                if emby_api_valid is True and jellystat_api_valid is True:
                     emby_user_id = self.emby_api.get_user_id(user_config.emby_user_name)
                     if emby_user_id != self.emby_api.get_invalid_item_id():
                         emby_user_name = user_config.emby_user_name
                     else:
                         emby_user_id = ''
                         self.log_warning('{} could not find {}'.format(utils.get_formatted_emby(), utils.get_tag('user', user_config.emby_user_name)))
                 else:
-                    if emby_api_valid == False:
+                    if emby_api_valid is False:
                         self.log_warning(self.emby_api.get_connection_error_log())
-                    if jellystat_api_valid == False:
+                    if jellystat_api_valid is False:
                         self.log_warning(self.jellystat_api.get_connection_error_log())
 
             if plex_user_name != '' or emby_user_name != '':
@@ -273,7 +273,7 @@ def __check_delete_media(self):
                         if notify_lib.id == media.library.id:
                             notify_lib_found = True
                             break
-                    if notify_lib_found == False:
+                    if notify_lib_found is False:
                         libraries_to_notify.append(media.library)
                 except Exception as e:
                     self.log_error('Failed to delete {} {}'.format(utils.get_tag('file', media.file_path), utils.get_tag('error', e)))

service/DvrMaintainer.py

@@ -100,7 +100,7 @@ def __get_files_in_path(self, path: str) -> List[FileInfo]:
         return file_info
 
     def __delete_file(self, pathFileName: str):
-        if self.run_test == True:
+        if self.run_test is True:
             self.log_info('Running test! Would delete {}'.format(utils.get_tag('file', pathFileName)))
         else:
             try:
@@ -145,18 +145,18 @@ def __check_library_delete_shows(self, library: LibraryConfig) -> List[DeletedDa
         deleted_data: list[DeletedData] = []
         for show in library.shows:
             library_file_path = library.utility_path + '/' + show.name
-            if os.path.exists(library_file_path) == True:
+            if os.path.exists(library_file_path) is True:
                 if show.action_type == 'KEEP_LAST':
                     try:
                         shows_deleted = self.__keep_last_delete(library_file_path, show.action_value)
-                        if shows_deleted == True:
+                        if shows_deleted is True:
                             deleted_data.append(DeletedData(library.id, library.plex_library_name, library.emby_library_name, library.emby_library_id))
                     except Exception as e:
                         self.log_error('Check show delete keep last {}'.format(utils.get_tag('error', e)))
                 elif show.action_type == 'KEEP_LENGTH_DAYS':
                     try:
                         shows_deleted = self.__keep_show_days(library_file_path, show.action_value)
-                        if shows_deleted == True:
+                        if shows_deleted is True:
                             deleted_data.append(DeletedData(library.id, library.plex_library_name, library.emby_library_name, library.emby_library_id))
                     except Exception as e:
                         self.log_error('Check show delete keep length {}'.format(utils.get_tag('error', e)))
@@ -181,7 +181,7 @@ def __get_library_data(self) -> List[LibraryConfig]:
         for library_config in self.library_configs:
             plex_library_name = ''
             if library_config.plex_library_name != '':
-                if self.plex_api.get_valid() == True:
+                if self.plex_api.get_valid() is True:
                     if self.plex_api.get_library(library_config.plex_library_name) != self.plex_api.get_invalid_type():
                         plex_library_name = library_config.plex_library_name
                     else:
@@ -192,7 +192,7 @@ def __get_library_data(self) -> List[LibraryConfig]:
             emby_library_name = ''
             emby_library_id = ''
             if library_config.emby_library_name != '':
-                if self.emby_api.get_valid() == True:
+                if self.emby_api.get_valid() is True:
                     library_id = self.emby_api.get_library_id(library_config.emby_library_name)
                     if library_id != self.emby_api.get_invalid_item_id():
                         emby_library_name = library_config.emby_library_name
@@ -225,14 +225,14 @@ def __do_maintenance(self):
                     if deleted_library.library_id == deleted_data.library_id:
                         library_in_list = True
                         break
-                if library_in_list == False:
+                if library_in_list is False:
                     deleted_libraries.append(deleted_data)
 
             for deleted_library in deleted_libraries:
                 target_name = ''
-                if self.__notify_plex_refresh(deleted_library.plex_library_name) == True:
+                if self.__notify_plex_refresh(deleted_library.plex_library_name) is True:
                     target_name = utils.build_target_string(target_name, utils.get_formatted_plex(), deleted_library.plex_library_name)
-                if self.__notify_emby_refresh(deleted_library.emby_library_id) == True:
+                if self.__notify_emby_refresh(deleted_library.emby_library_id) is True:
                     target_name = utils.build_target_string(target_name, utils.get_formatted_emby(), deleted_library.emby_library_name)
 
                 if target_name != '':

service/FolderCleanup.py

@@ -63,7 +63,7 @@ def __is_dir_empty(self, dirnames: List[str]) -> bool:
             else:
                 dir_empty = False
 
-            if dir_empty == False:
+            if dir_empty is False:
                 break
         return dir_empty
 
@@ -78,33 +78,33 @@ def __is_files_empty(self, filenames: List[str]) -> bool:
             else:
                 filenames_empty = False
 
-            if filenames_empty == False:
+            if filenames_empty is False:
                 break
         return filenames_empty
 
     def __check_delete_empty_folders(self):
         deleted_paths: list[PathInfo] = []
         for path in self.paths:
             connection_info = utils_server.get_connection_info(self.plex_api, path.plex_library_name, self.emby_api, path.emby_library_name)
-            if (path.plex_library_name == '' or connection_info.plex_valid == True) and (path.emby_library_name == '' or connection_info.emby_valid == True):
+            if (path.plex_library_name == '' or connection_info.plex_valid is True) and (path.emby_library_name == '' or connection_info.emby_valid is True):
                 folders_deleted = False
 
                 keep_running = True
-                while keep_running == True:
+                while keep_running is True:
                     keep_running = False
                     for dirpath, dirnames, filenames in os.walk(path.path, topdown=False):
-                        if self.__is_dir_empty(dirnames) == True and self.__is_files_empty(filenames) == True:
+                        if self.__is_dir_empty(dirnames) is True and self.__is_files_empty(filenames) is True:
                             self.log_info('Deleting empty {}'.format(utils.get_tag('folder', dirpath)))
                             shutil.rmtree(dirpath, ignore_errors=True)
                             keep_running = True
                             folders_deleted = True
 
-                if folders_deleted == True:
+                if folders_deleted is True:
                     deleted_paths.append(PathInfo(path.path, path.plex_library_name, path.emby_library_name, connection_info.emby_library_id))
             else:
-                if path.plex_library != '' and connection_info.plex_valid == False:
+                if path.plex_library_name != '' and connection_info.plex_valid is False:
                     self.log_warning(self.plex_api.get_connection_error_log())
-                if path.emby_library_name != '' and connection_info.emby_valid == False:
+                if path.emby_library_name != '' and connection_info.emby_valid is False:
                     self.log_warning(self.emby_api.get_connection_error_log())
 
         for deleted_path in deleted_paths: