Merge pull request #1 from brikim/playlistSync

brikim · web-flow · commit 27d3a64c6ef6 · 2025-02-22T17:47:41.000-06:00
Playlist sync
diff --git a/api/emby.py b/api/emby.py
@@ -1,8 +1,21 @@
 import requests
+import json
 from logging import Logger
 from typing import Any
 from common import utils
+from dataclasses import dataclass, field
 
+@dataclass
+class EmbyPlaylistItem:
+    name: str
+    id: str
+    
+@dataclass
+class EmbyPlaylist:
+    name: str
+    id: str
+    items: list[EmbyPlaylistItem] = field(default_factory=list)
+    
 class EmbyAPI:
     def __init__(self, url: str, api_key: str, media_path: str, logger: Logger):
         self.url = url.rstrip('/')
@@ -172,3 +185,94 @@ def get_library_id(self, name: str) -> Any:
             pass
         
         return self.invalid_item_id
+    
+    def get_playlist_id(self, playlist_name: str) -> str:
+        try:
+            payload = {
+                'api_key': self.api_key,
+                'SearchTerm': playlist_name,
+                'Recursive': 'true',
+                'Fields': 'Path'}
+            r = requests.get(self.__get_api_url() + '/Items', params=payload)
+            response = r.json()
+
+            for item in response['Items']:
+                if item['Type'] == 'Playlist' and item['Name'] == playlist_name:
+                    return item['Id']
+            
+        except Exception as e:
+            self.logger.error("{} get_item_id_from_path {} {}".format(self.log_header, utils.get_tag('path', path), utils.get_tag('error', e)))
+            
+        return self.get_invalid_item_id()
+    
+    def __get_comma_separated_list(self, list_to_separate: list[str]) -> str:
+        comma_separated_ids = ''
+        for list_item in list_to_separate:
+            comma_separated_ids += list_item + ','
+        return comma_separated_ids.rstrip(',')
+        
+    def create_playlist(self, playlist_name: str, ids: list[str]) -> str:
+        try:
+            headers = {'accept': 'application/json'}
+            payload = {
+                'Name': playlist_name,
+                'Ids': self.__get_comma_separated_list(ids),
+                'MediaType': 'Movies'}
+            embyUrl = self.__get_api_url() + '/Playlists' + '?api_key=' + self.api_key
+            r = requests.post(embyUrl, headers=headers, data=payload)
+            if r.status_code < 300:
+                response = r.json()
+                return response['Id']
+        except Exception as e:
+            self.logger.error("{} create_playlist {} error {}".format(self.log_header, utils.get_tag('playlist', playlist_name), utils.get_tag('error', e)))
+        return self.invalid_item_id()
+    
+    def get_playlist_items(self, playlist_id: str) -> EmbyPlaylist:
+        try:
+            playlist = self.search_item(playlist_id)
+            
+            payload = {
+                'api_key': self.api_key}
+            r = requests.get(self.__get_api_url() + '/Playlists/' + playlist_id + '/Items', params=payload)
+            response = r.json()
+
+            emby_playlist = EmbyPlaylist(playlist['Name'], playlist_id)
+            for item in response['Items']:
+                emby_playlist.items.append(EmbyPlaylistItem(item['Name'], item['Id']))
+
+            return emby_playlist
+        except Exception as e:
+            self.logger.error("{} get_playlist_items {} error {}".format(self.log_header, utils.get_tag('playlist_id', playlist_id), utils.get_tag('error', e)))
+        
+        return None
+
+    def add_playlist_items(self, playlist_id: str, item_ids: list[str]):
+        try:
+            headers = {'accept': 'application/json'}
+            payload = {
+                'Ids ': self.__get_comma_separated_list(item_ids)}
+            embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items' + '?api_key=' + self.api_key
+            r = requests.post(embyUrl, headers=headers, data=payload)
+            pass
+        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)))
+            
+    def remove_playlist_items(self, playlist_id: str, item_ids: list[str]):
+        try:
+            headers = {'accept': 'application/json'}
+            payload = {
+                'EntryIds': self.__get_comma_separated_list(item_ids)}
+            embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items/Delete' + '?api_key=' + self.api_key
+            r = requests.post(embyUrl, headers=headers, data=payload)
+            pass
+        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('item_ids', item_ids), utils.get_tag('error', e)))
+            
+    def set_move_playlist_item_to_index(self, playlist_id: str, item_id: str, index: int):
+        try:
+            headers = {'accept': 'application/json'}
+            embyUrl = self.__get_api_url()+ '/Playlists/' + playlist_id + '/Items/' + item_id + '/Move/' + str(index) + '?api_key=' + self.api_key
+            r = requests.post(embyUrl, headers=headers)
+            pass
+        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('item_id', item_id), utils.get_tag('move_index', index), utils.get_tag('error', e)))
diff --git a/api/plex.py b/api/plex.py
@@ -1,13 +1,24 @@
 from logging import Logger
 from typing import Any
-from plexapi.server import PlexServer
+from plexapi import server, collection
 from common import utils
+from dataclasses import dataclass, field
 
+@dataclass
+class PlexCollectionItem:
+    title: str
+    path: str
+    
+@dataclass
+class PlexCollection:
+    name: str
+    items: list[PlexCollectionItem] = field(default_factory=list)
+    
 class PlexAPI:
     def __init__(self, url: str, api_key: str, admin_user_name: str, media_path: str, logger: Logger):
         self.url = url
         self.api_key = api_key
-        self.plex_server = PlexServer(url.rstrip('/'), api_key)
+        self.plex_server = server.PlexServer(url.rstrip('/'), api_key)
         self.admin_user_name = admin_user_name
         self.media_path = media_path
         self.logger = logger
@@ -46,7 +57,7 @@ def switch_plex_account(self, user_name):
             if current_user.username != user_name:
                 self.plex_server.switchUser(user_name)
         except Exception as e:
-            self.logger.error("{} switch_plex_account {} {}".format(self.log_header,  utils.get_tag('user', user_name),  utils.get_tag('error', e)))
+            self.logger.error('{} switch_plex_account {} {}'.format(self.log_header,  utils.get_tag('user', user_name),  utils.get_tag('error', e)))
     
     def switch_plex_account_admin(self):
         self.switch_plex_account(self.admin_user_name)
@@ -81,7 +92,7 @@ def set_library_scan(self, library_name: str):
             library = self.plex_server.library.section(library_name)
             library.update()
         except Exception as e:
-            self.logger.error("{} set_library_scan {} {}".format(self.log_header,  utils.get_tag('library', library_name),  utils.get_tag('error', e)))
+            self.logger.error('{} set_library_scan {} {}'.format(self.log_header,  utils.get_tag('library', library_name),  utils.get_tag('error', e)))
             
     def get_library_name_from_path(self, path: str) -> str:
         # Get all libraries
@@ -91,5 +102,29 @@ def get_library_name_from_path(self, path: str) -> str:
                 if location == path:
                     return library.title
         
-        self.logger.warning("{} No library found with {}".format(self.log_header,  utils.get_tag('path', path)))
-        return ''
+        self.logger.warning('{} No library found with {}'.format(self.log_header,  utils.get_tag('path', path)))
+        return ''
+    
+    def get_collection_valid(self, library_name: str, collection_name: str) -> bool:
+        try:
+            library = self.plex_server.library.section(library_name)
+            for collection in library.collections():
+                if collection.title == collection_name:
+                    return True
+        except Exception as e:
+            pass
+        return False
+    
+    def get_collection(self, library_name: str, collection_name: str) -> PlexCollection:
+        try:
+            library = self.plex_server.library.section(library_name)
+            for collection in library.collections():
+                if collection.title == collection_name:
+                    items: list[PlexCollectionItem] = []
+                    for item in collection.children:
+                        if len(item.locations) > 0:
+                            items.append(PlexCollectionItem(item.title, item.locations[0]))
+                    return PlexCollection(collection.title, items)
+        except Exception as e:
+            pass
+        return self.get_invalid_type()
diff --git a/app.py b/app.py
@@ -2,7 +2,7 @@
 Media Utilities
 """
 
-version = 'v2.1.0'
+version = 'v2.2.0'
 
 import sys
 import os
@@ -29,6 +29,7 @@
 from service.DvrMaintainer import DvrMaintainer
 from service.FolderCleanup import FolderCleanup
 from service.SyncWatched import SyncWatched
+from service.PlaylistSync import PlaylistSync
 
 # Global Variables #######
 logger = logging.getLogger(__name__)
@@ -161,6 +162,8 @@ def do_nothing():
             services.append(DvrMaintainer('\33[95m', plex_api, emby_api, data['dvr_maintainer'], logger, scheduler))
         if 'folder_cleanup' in data and data['folder_cleanup']['enabled'] == 'True':
             services.append(FolderCleanup('\33[33m', plex_api, emby_api, data['folder_cleanup'], logger, scheduler))
+        if 'playlist_sync' in data and data['playlist_sync']['enabled'] == 'True':
+            services.append(PlaylistSync('\33[94m', plex_api, emby_api, data['playlist_sync'], logger, scheduler))
         
         # ########################################################
         
diff --git a/config/configDefault.conf b/config/configDefault.conf
@@ -89,5 +89,13 @@
         "ignore_file_in_empty_check": [
             {"ignore_file": "someFileToIgnore"}
         ]
+    },
+
+    "playlist_sync": {
+        "enabled": "True",
+        "cron_run_rate": "0 */2",
+        "plex_collection_sync": {
+            {"library": "plexLibraryName", "collection_name": "plexCollectionName", "target_servers": "emby"}
+        }
     }
 }
diff --git a/service/PlaylistSync.py b/service/PlaylistSync.py
@@ -0,0 +1,140 @@
+from logging import Logger
+from apscheduler.schedulers.blocking import BlockingScheduler
+from dataclasses import dataclass, field
+from common import utils
+
+from service.ServiceBase import ServiceBase
+
+from api.plex import PlexAPI, PlexCollection
+from api.emby import EmbyAPI, EmbyPlaylist
+
+@dataclass
+class PlexCollectionConfig:
+    library_name: str
+    collection_name: str
+    target_servers: list[str] = field(default_factory=list)
+
+class PlaylistSync(ServiceBase):
+    def __init__(self, ansi_code: str, plex_api: PlexAPI, emby_api: EmbyAPI, config, logger: Logger, scheduler: BlockingScheduler):
+        super().__init__(ansi_code, self.__module__, config, logger, scheduler)
+        
+        self.plex_api = plex_api
+        self.emby_api = emby_api
+        self.plex_collection_configs: list[PlexCollectionConfig] = []
+        
+        try:
+            for plex_collection in config['plex_collection_sync']:
+                if 'library' in plex_collection and 'collection_name' in plex_collection and 'target_servers' in plex_collection:
+                    library_name = plex_collection['library']
+                    collection_name = plex_collection['collection_name']
+                    target_servers: list[str] = []
+                    
+                    target_server_names = plex_collection['target_servers'].split(',')
+                    for target_server_name in target_server_names:
+                        supported_target_server_name = self.__server_supported(target_server_name)
+                        if supported_target_server_name != '':
+                            target_servers.append(supported_target_server_name)
+                    
+                    if library_name != '' and collection_name != '' and len(target_servers) > 0:
+                        if plex_api.get_valid() is True and plex_api.get_collection_valid(library_name, collection_name) is False:
+                            self.log_warning('{} {} {} not found on server'.format(utils.get_formatted_plex(), utils.get_tag('library', library_name), utils.get_tag('collection', collection_name)))
+                        
+                        self.plex_collection_configs.append(PlexCollectionConfig(library_name, collection_name, target_servers))
+            
+        except Exception as e:
+            self.log_error('Read config {}'.format(utils.get_tag('error', e)))
+
+    def __server_supported(self, server_type: str) -> str:
+        lower_name = server_type.lower()
+        if (lower_name == 'plex' or lower_name == 'emby'):
+            return lower_name
+        return ''
+    
+    def __sync_emby_playlist(self, emby_item_ids: list[str], emby_playlist: EmbyPlaylist):
+        # Check if any items were added to the playlist
+        added_items: list[str] = []
+        for emby_item_id in emby_item_ids:
+            item_id_found = False
+            for item in emby_playlist.items:
+                if emby_item_id == item.id:
+                    item_id_found = True
+                    break
+            if item_id_found is False:
+                added_items.append(emby_item_id)
+        
+        # Check if any items were deleted out of the playlist
+        deleted_items: list[str] = []
+        for item in emby_playlist.items:
+            if item.id not in emby_item_ids:
+                deleted_items.append(item.id)
+                
+        # Check if the order of the playlist items changed
+        playlist_changed = False
+        if len(emby_item_ids) == len(emby_playlist.items):
+            playlist_index = 0
+            for item_id in emby_item_ids:
+                if item_id != emby_playlist.items[playlist_index].id:
+                    playlist_changed = True
+                    break
+                playlist_index += 1
+        else:
+            playlist_changed = True
+            
+        if playlist_changed is True or len(added_items) > 0 or len(deleted_items) > 0:
+            self.log_info('Syncing {} {} to {}'.format(utils.get_formatted_plex(), utils.get_tag('collection', emby_playlist.name), utils.get_formatted_emby()))
+        
+            if len(added_items) > 0:
+                self.emby_api.add_playlist_items(emby_playlist.id, added_items)
+            
+            if len(deleted_items) > 0:
+                self.emby_api.remove_playlist_items(emby_playlist.id, deleted_items)
+            
+            current_index = 1
+            for item_id in emby_item_ids:
+                self.emby_api.set_move_playlist_item_to_index(emby_playlist.id, item_id, current_index)
+                current_index += 1
+    
+    def __sync_emby_playlist_with_plex_collection(self, plex_collection: PlexCollection):
+        emby_item_ids: list[str] = []
+        for plex_item in plex_collection.items:
+            emby_item_id = self.emby_api.get_item_id_from_path(plex_item.path)
+            if emby_item_id != self.emby_api.get_invalid_item_id():
+                emby_item_ids.append(emby_item_id)
+            else:
+                self.log_warning('{} sync {} {} item not found {}'.format(utils.get_emby_ansi_code(), utils.get_plex_ansi_code(), utils.get_tag('collection', plex_collection.name), utils.get_tag('item', plex_item.title)))
+        
+        emby_playlist_id = self.emby_api.get_playlist_id(plex_collection.name)
+        if emby_playlist_id == self.emby_api.get_invalid_item_id():
+            self.emby_api.create_playlist(plex_collection.name, emby_item_ids)
+            self.log_info('Syncing {} {} to {}'.format(utils.get_formatted_plex(), utils.get_tag('collection', plex_collection.name), utils.get_formatted_emby()))
+        else:
+            emby_playlist:EmbyPlaylist = self.emby_api.get_playlist_items(emby_playlist_id)
+            if emby_playlist is not None:
+                self.__sync_emby_playlist(emby_item_ids, emby_playlist)
+    
+    def __sync_plex_collection(self, collection_config: PlexCollectionConfig):
+        collection: PlexCollection = self.plex_api.get_collection(collection_config.library_name, collection_config.collection_name)
+        if collection != self.plex_api.get_invalid_type():
+            for target_server in collection_config.target_servers:
+                if target_server == 'emby' and self.emby_api.get_valid() is True:
+                    self.__sync_emby_playlist_with_plex_collection(collection)
+    
+    def __sync_playlists(self):
+        if len(self.plex_collection_configs) > 0:
+            plex_valid = self.plex_api.get_valid()
+            emby_valid = self.emby_api.get_valid()
+            if plex_valid is True and emby_valid is True:
+                for plex_collection_config in self.plex_collection_configs:
+                    self.__sync_plex_collection(plex_collection_config)
+            else:
+                if plex_valid is False:
+                    self.log_warning(self.plex_api.get_connection_error_log())
+                if emby_valid is False:
+                    self.log_warning(self.emby_api.get_connection_error_log())
+    
+    def init_scheduler_jobs(self):
+        if self.cron is not None:
+            self.log_service_enabled()
+            self.scheduler.add_job(self.__sync_playlists, trigger='cron', hour=self.cron.hours, minute=self.cron.minutes)
+        else:
+            self.log_warning('Enabled but will not Run. Cron is not valid!')

Original file line number	Diff line number	Diff line change
`@@ -89,5 +89,13 @@`
`89`	`89`	`"ignore_file_in_empty_check": [`
`90`	`90`	`{"ignore_file": "someFileToIgnore"}`
`91`	`91`	`]`
	`92`	`+ },`
	`93`	`+`
	`94`	`+ "playlist_sync": {`
	`95`	`+ "enabled": "True",`
	`96`	`+ "cron_run_rate": "0 */2",`
	`97`	`+ "plex_collection_sync": {`
	`98`	`+ {"library": "plexLibraryName", "collection_name": "plexCollectionName", "target_servers": "emby"}`
	`99`	`+ }`
`92`	`100`	`}`
`93`	`101`	`}`