コード例 #1
0
class SmartPlay:
    def __init__(self, actionArgs):
        self.actionArgs = actionArgs
        self.info_dictionary = tools.get_item_information(actionArgs)

        if type(self.info_dictionary) is not dict:
            raise Exception

        try:
            self.show_trakt_id = self.info_dictionary['showInfo']['ids'][
                'trakt']
        except:
            self.show_trakt_id = self.info_dictionary['ids']['trakt']
        self.display_style = tools.getSetting('smartplay.displaystyle')
        self.window = BackgroundWindowAdapter()

    def get_season_info(self):
        return database.get(
            TraktAPI().json_response, 12,
            'shows/%s/seasons?extended=full' % self.show_trakt_id)

    def fill_playlist(self, params=None):
        try:
            tools.cancelPlayback()
        except:
            import traceback
            traceback.print_exc()
            pass
        tools.closeAllDialogs()

        if self.display_style == '0':
            self.window = PersistentBackground(
                *SkinManager().confirm_skin_path('persistent_background.xml'),
                actionArgs=self.actionArgs)

        self.window.setText(tools.lang(32094))
        self.window.show()

        self.window.setText(tools.lang(32095))

        tools.playList.clear()

        season = self.info_dictionary['info']['season']
        episode = self.info_dictionary['info']['episode']

        self.window.setText(tools.lang(32096))

        self.window.setText(tools.lang(32097))

        self.build_playlist(season, episode, params=params)

        self.window.setText(tools.lang(40322))

        tools.log(
            'Begining play from Season %s Episode %s' % (season, episode),
            'info')

        self.window.close()

        tools.player().play(tools.playList)

    def resume_playback(self):

        tools.playList.clear()

        if self.display_style == '0':
            self.window = PersistentBackground(
                *SkinManager().confirm_skin_path('persistent_background.xml'),
                actionArgs=self.actionArgs)
        self.window.show()
        self.window.setText(tools.lang(32095).encode('utf-8'))

        if tools.getSetting('trakt.auth') == '':
            tools.showDialog.ok(tools.addonName,
                                tools.lang(32093).encode('utf-8'))
            self.window.close()
            return

        playback_history = TraktAPI().json_response('sync/history/shows/%s' %
                                                    self.show_trakt_id)

        self.window.setText(tools.lang(32096).encode('utf-8'))

        season, episode = self.get_resume_episode(playback_history)

        self.build_playlist(season, episode)

        self.window.close()

        tools.player().play(tools.playList)

    @staticmethod
    def clean_playback_params(params):
        if params is not None:

            # Do not apply the resume function to all items in the list
            if 'resume' in params:
                params.pop('resume')

            params.pop('actionArgs')
            params.pop('action')

            return tools.urlencode(params)

    def build_playlist(self, season=None, minimum_episode=None, params=None):

        if season is None:
            season = self.info_dictionary['info']['season']

        if minimum_episode is None:
            minimum_episode = int(self.info_dictionary['info']['episode']) + 1

        url_params = self.clean_playback_params(params)

        playlist = tvshowMenus.Menus().episodeListBuilder(self.show_trakt_id,
                                                          season,
                                                          smartPlay=True)

        for i in playlist:
            params = dict(tools.parse_qsl(i[0].replace('?', '')))
            actionArgs = params.get('actionArgs')

            if not tvshowMenus.Menus().is_aired(
                    tools.get_item_information(actionArgs)['info']):
                tools.log('Episode not Aired, skipping')
                continue

            actionArgs = json.loads(actionArgs)

            if actionArgs['episode'] < minimum_episode:
                continue

            url = i[0]

            if actionArgs['episode'] == minimum_episode:
                request_args = json.loads(tools.unquote(self.actionArgs))
                # actionArgs['resume'] = request_args['resume'] if 'resume' in request_args else 'false'
                url = '&actionArgs='.join([
                    url.split('&actionArgs=')[0],
                    tools.quote(json.dumps(actionArgs, sort_keys=True))
                ])

            if url_params is not None:
                url += '&{}'.format(url_params)

            tools.playList.add(url=url, listitem=i[1])

    def get_resume_episode(self, playback_history):

        try:

            episode_info = playback_history[0]
            season = episode_info['episode']['season']
            episode = episode_info['episode']['number']

            # Continue watching from last unfinished episode
            if episode_info['action'] == 'watch':
                return season, episode
            else:
                # Move on to next episode
                episode += 1

            # Get information for new season and check whether we are finished the season
            relevant_season_info = [
                i for i in self.get_season_info() if i['number'] == season
            ][0]

            if episode >= relevant_season_info['episode_count']:
                season += 1
                episode = 1

            if self.final_episode_check(season, episode):
                season = 1
                episode = 1

            return season, episode
        except:
            return 1, 1

    def final_episode_check(self, season, episode):

        season = int(season)
        episode = int(episode)

        last_aired = TraktAPI().json_response('shows/%s/last_episode' %
                                              self.show_trakt_id)

        if season > last_aired['season']:
            return True

        if season == last_aired['season']:
            if episode == last_aired['number']:
                return True

        return False

    def append_next_season(self, params=None):

        season = self.info_dictionary['info']['season']
        episode = self.info_dictionary['info']['episode']

        season_info = self.get_season_info()

        current_season_info = [
            i for i in season_info if season == i['number']
        ][0]

        if episode == current_season_info['episode_count']:

            if len([i for i in season_info if i['number'] == season + 1]) == 0:
                return False

            episode = 1
            season += 1

            self.build_playlist(season, episode, params=params)

        else:
            return False

    def pre_scrape(self):

        try:
            current_position = tools.playList.getposition()
            url = tools.playList[current_position + 1].getPath()
        except:
            url = None

        if url is None: return

        url = url.replace('getSources', 'preScrape')

        tools.setSetting(id='general.tempSilent', value='true')
        tools.execute('RunPlugin("%s")' % url)

    def torrent_file_picker(self):
        tools.playList.clear()
        info = self.info_dictionary
        episode = info['info']['episode']
        season = info['info']['season']
        show_id = info['showInfo']['ids']['trakt']

        list_item = tvshowMenus.Menus().episodeListBuilder(show_id,
                                                           season,
                                                           hide_unaired=True,
                                                           smartPlay=True)
        url = list_item[0] + "&packSelect=true"
        tools.playList.add(url=url, listitem=list_item[1])
        tools.player().play(tools.playList)

    def shufflePlay(self):

        import random

        if self.display_style == '0':
            self.window = PersistentBackground(
                *SkinManager().confirm_skin_path('persistent_background.xml'),
                actionArgs=self.actionArgs)
        self.window.show()
        self.window.setText(tools.lang(32096))

        tools.playList.clear()

        season_list = TraktAPI().json_response(
            'shows/%s/seasons?extended=episodes' % self.show_trakt_id)
        if season_list[0]['number'] == 0:
            season_list.pop(0)

        self.window.setText(tools.lang(32097))

        episode_list = [
            episode for season in season_list for episode in season['episodes']
        ]
        random.shuffle(episode_list)
        episode_list = episode_list[:40]
        shuffle_list = []

        for episode in episode_list:
            shuffle_list.append({
                'episode': episode,
                'show': {
                    'ids': {
                        'trakt': self.show_trakt_id
                    }
                }
            })

        # mill the episodes
        playlist = tvshowMenus.Menus().mixedEpisodeBuilder(shuffle_list,
                                                           sort=False,
                                                           smartPlay=True)

        self.window.setText(tools.lang(32098))

        for episode in playlist:
            if episode is not None:
                tools.playList.add(url=episode[0], listitem=episode[1])

        self.window.close()

        tools.playList.shuffle()
        tools.player().play(tools.playList)

    def play_from_random_point(self):

        import random

        tools.playList.clear()

        random_season = random.randint(
            1, int(self.info_dictionary['info']['season_count']))

        playlist = tvshowMenus.Menus().episodeListBuilder(self.show_trakt_id,
                                                          random_season,
                                                          smartPlay=True,
                                                          hide_unaired=True)
        random_episode = random.randint(0, len(playlist) - 1)

        playlist = playlist[random_episode]

        tools.playList.add(url=playlist[0], listitem=playlist[1])

        tools.player().play(tools.playList)

    def getSourcesWorkaround(self, actionArgs):

        tools.execute(
            'RunPlugin(plugin://plugin.video.%s?action=getSourcesWorkaround2&actionArgs=%s)'
            % (tools.addonName.lower(), tools.quote(actionArgs)))

    def getSourcesWorkaround2(self, actionArgs):

        item_information = tools.get_item_information(actionArgs)
        item = tools.menuItem(label=item_information['info']['title'])
        item.setArt(item_information['art'])
        item.setUniqueIDs(item_information['ids'])
        item.setInfo(type='video',
                     infoLabels=tools.clean_info_keys(
                         item_information['info']))
        tools.playList.add(
            url='plugin://plugin.video.%s?action=getSources&actionArgs=%s' %
            (tools.addonName.lower(), tools.quote(actionArgs)),
            listitem=item)
        tools.player().play(tools.playList)

    def workaround(self):
        tools.execute(
            'RunPlugin(plugin://plugin.video.%s?action=buildPlaylistWorkaround&actionArgs=%s)'
            % (tools.addonName.lower(), tools.quote(self.actionArgs)))
コード例 #2
0
ファイル: smartPlay.py プロジェクト: zois1/plugin.video.seren
class SmartPlay:
    def __init__(self, actionArgs):
        self.actionArgs = actionArgs
        self.info_dictionary = tools.get_item_information(actionArgs)

        if type(self.info_dictionary) is not dict:
            raise Exception

        try:
            self.poster = self.info_dictionary['showInfo']['art'].get(
                'fanart', '')
            self.show_trakt_id = self.info_dictionary['showInfo']['ids'][
                'trakt']
        except:
            self.poster = self.info_dictionary['art'].get('fanart', '')
            self.show_trakt_id = self.info_dictionary['ids']['trakt']

        self.window = None

    def get_season_info(self):
        return database.get(
            TraktAPI().json_response, 12,
            'shows/%s/seasons?extended=full' % self.show_trakt_id)

    def fill_playlist(self):
        self.window = PersistentBackground('persistent_background.xml',
                                           tools.addonDir,
                                           actionArgs=self.actionArgs)
        self.window.setText(tools.lang(32094))
        self.window.show()

        self.window.setText(tools.lang(32095))

        tools.playList.clear()

        season = self.info_dictionary['info']['season']
        episode = self.info_dictionary['info']['episode']

        self.window.setText(tools.lang(32096))

        self.window.setText(tools.lang(32097))

        self._build_playlist(season, episode)

        self.window.setText('Starting Playback')

        tools.log(
            'Begining play from Season %s Episode %s' % (season, episode),
            'info')

        self.window.close()

        tools.player().play(tools.playList)

    def resume_playback(self):

        self.window = PersistentBackground('persistent_background.xml',
                                           tools.addonDir,
                                           actionArgs=self.actionArgs)
        self.window.show()
        self.window.setText(tools.lang(32095).encode('utf-8'))

        if tools.getSetting('trakt.auth') == '':
            tools.showDialog.ok(tools.addonName,
                                tools.lang(32093).encode('utf-8'))
            self.window.close()
            return

        playback_history = TraktAPI().json_response('sync/history/shows/%s' %
                                                    self.show_trakt_id)

        self.window.setText(tools.lang(32096).encode('utf-8'))

        season, episode = self.get_resume_episode(playback_history)

        self._build_playlist(season, episode)

        self.window.close()

        tools.player().play(tools.playList)

    def _build_playlist(self, season, minimum_episode):

        playlist = tvshowMenus.Menus().episodeListBuilder(self.show_trakt_id,
                                                          season,
                                                          smartPlay=True)

        for i in playlist:
            # Confirm that the episode meta we have received from TVDB are for the correct episodes
            # If trakt provides the incorrect TVDB ID it's possible to begin play from the incorrect episode
            params = dict(tools.parse_qsl(i[0].replace('?', '')))
            actionArgs = json.loads(params.get('actionArgs'))

            if actionArgs['episode'] < minimum_episode:
                continue

            # If the episode is confirmed ok, add it to our playlist.
            if tvshowMenus.Menus().is_aired(
                    tools.get_item_information(
                        json.dumps(actionArgs))['info']):
                tools.playList.add(url=i[0], listitem=i[1])

    def get_resume_episode(self, playback_history):

        try:

            episode_info = playback_history[0]
            season = episode_info['episode']['season']
            episode = episode_info['episode']['number']

            # Continue watching from last unfinished episode
            if episode_info['action'] == 'watch':
                return season, episode
            else:
                # Move on to next episode
                episode += 1

            # Get information for new season and check whether we are finished the season
            relevant_season_info = [
                i for i in self.get_season_info() if i['number'] == season
            ][0]

            if episode >= relevant_season_info['episode_count']:
                season += 1
                episode = 1

            if self.final_episode_check(season, episode):
                season = 1
                episode = 1

            return season, episode
        except:
            return 1, 1

    def final_episode_check(self, season, episode):

        season = int(season)
        episode = int(episode)

        last_aired = TraktAPI().json_response('shows/%s/last_episode' %
                                              self.show_trakt_id)

        if season > last_aired['season']:
            return True

        if season == last_aired['season']:
            if episode == last_aired['number']:
                return True

        return False

    def append_next_season(self):

        season = self.info_dictionary['info']['season']
        episode = self.info_dictionary['info']['episode']

        season_info = self.get_season_info()

        current_season_info = [
            i for i in season_info if season == i['number']
        ][0]

        if episode == current_season_info['episode_count']:

            if len([i for i in season_info if i['number'] == season + 1]) == 0:
                return False

            episode = 1
            season += 1

            self._build_playlist(season, episode)

        else:
            return False

    def pre_scrape(self):

        try:
            current_position = tools.playList.getposition()
            url = tools.playList[current_position + 1].getPath()
        except:
            url = None

        if url is None: return

        url = url.replace('getSources', 'preScrape')

        tools.setSetting(id='general.tempSilent', value='true')
        tools.execute('RunPlugin("%s")' % url)

    def torrent_file_picker(self):
        tools.playList.clear()
        info = self.info_dictionary
        episode = info['info']['episode']
        season = info['info']['season']
        show_id = info['showInfo']['ids']['trakt']

        list_item = tvshowMenus.Menus().episodeListBuilder(show_id,
                                                           season,
                                                           hide_unaired=True,
                                                           smartPlay=True)
        url = list_item[0] + "&packSelect=true"
        tools.playList.add(url=url, listitem=list_item[1])
        tools.player().play(tools.playList)

    def shufflePlay(self):

        import random

        self.window = PersistentBackground('persistent_background.xml',
                                           tools.addonDir,
                                           actionArgs=self.actionArgs)
        self.window.show()
        self.window.setText(tools.lang(32096))

        tools.playList.clear()

        season_list = TraktAPI().json_response(
            'shows/%s/seasons?extended=episodes' % self.show_trakt_id)
        if season_list[0]['number'] == 0:
            season_list.pop(0)

        self.window.setText(tools.lang(32097))

        episode_list = [
            episode for season in season_list for episode in season['episodes']
        ]
        random.shuffle(episode_list)
        episode_list = episode_list[:40]
        shuffle_list = []

        for episode in episode_list:
            shuffle_list.append({
                'episode': episode,
                'show': {
                    'ids': {
                        'trakt': self.show_trakt_id
                    }
                }
            })

        # mill the episodes
        playlist = tvshowMenus.Menus().mixedEpisodeBuilder(shuffle_list,
                                                           sort=False,
                                                           smartPlay=True)

        self.window.setText(tools.lang(32098))

        for episode in playlist:
            if episode is not None:
                tools.playList.add(url=episode[0], listitem=episode[1])

        self.window.close()

        tools.playList.shuffle()
        tools.player().play(tools.playList)

    def play_from_random_point(self):

        import random
        random_season = random.randint(
            1, int(self.info_dictionary['showInfo']['info']['season_count']))

        playlist = tvshowMenus.Menus().episodeListBuilder(self.show_trakt_id,
                                                          random_season,
                                                          smartPlay=True,
                                                          hide_unaired=True)

        random_episode = random.randint(0, int(len(playlist)))

        playlist = playlist[random_episode:]

        tools.player().play(playlist[0])

    def getSourcesWorkaround(self, actionArgs):

        tools.execute(
            'RunPlugin(plugin://plugin.video.%s?action=getSourcesWorkaround2&actionArgs=%s)'
            % (tools.addonName.lower(), tools.quote(actionArgs)))

    def getSourcesWorkaround2(self, actionArgs):

        item_information = tools.get_item_information(actionArgs)
        item = tools.menuItem(label=item_information['info']['title'])
        item.setArt(item_information['art'])
        item.setUniqueIDs(item_information['ids'])
        item.setInfo(type='video',
                     infoLabels=tools.clean_info_keys(
                         item_information['info']))
        tools.playList.add(
            url='plugin://plugin.video.%s?action=getSources&actionArgs=%s' %
            (tools.addonName.lower(), tools.quote(actionArgs)),
            listitem=item)
        tools.player().play(tools.playList)

    def workaround(self):
        tools.execute(
            'RunPlugin(plugin://plugin.video.%s?action=buildPlaylistWorkaround&actionArgs=%s)'
            % (tools.addonName.lower(), tools.quote(self.actionArgs)))
コード例 #3
0
ファイル: seren.py プロジェクト: zois1/plugin.video.seren
def api(params):

    from resources.lib.common import tools
    from resources.lib.modules import database

    tools.SETTINGS_CACHE = {}

    try:

        url = params.get('url')

        action = params.get('action')

        page = params.get('page')

        actionArgs = params.get('actionArgs')

        pack_select = params.get('packSelect')

        source_select = params.get('source_select')

        seren_reload = params.get('seren_reload')

        if seren_reload == 'true':
            seren_reload = True

    except:

        print('Welcome to console mode')
        print('Command Help:')
        print('   - Menu Number: opens the relevant menu page')
        print('   - shell: opens a interactive python shell within Seren')
        print('   - action xxx: run a custom Seren URL argument')

        url = ''

        action = None

        page = ''

        actionArgs = ''

        pack_select = ''

        source_select = ''

        seren_reload = ''

    unit_tests = params.get('unit_tests', False)

    if unit_tests:
        tools.enable_unit_tests()

    tools.log('Seren, Running Path - Action: %s, actionArgs: %s' %
              (action, actionArgs))

    if action == None:
        from resources.lib.gui import homeMenu

        homeMenu.Menus().home()

    if action == 'smartPlay':
        from resources.lib.modules import smartPlay
        smartPlay.SmartPlay(actionArgs).fill_playlist()

    if action == 'playbackResume':
        from resources.lib.modules import smartPlay

        smart = smartPlay.SmartPlay(actionArgs)
        smart.workaround()

    if action == 'moviesHome':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().discoverMovies()

    if action == 'moviesPopular':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesPopular(page)

    if action == 'moviesTrending':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesTrending(page)

    if action == 'moviesPlayed':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesPlayed(page)

    if action == 'moviesWatched':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesWatched(page)

    if action == 'moviesCollected':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesCollected(page)

    if action == 'moviesAnticipated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesAnticipated(page)

    if action == 'moviesBoxOffice':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesBoxOffice()

    if action == 'moviesUpdated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesUpdated(page)

    if action == 'moviesRecommended':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesRecommended()

    if action == 'moviesSearch':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearch(actionArgs)

    if action == 'moviesSearchResults':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearchResults(actionArgs)

    if action == 'moviesSearchHistory':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearchHistory()

    if action == 'myMovies':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovies()

    if action == 'moviesMyCollection':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovieCollection()

    if action == 'moviesMyWatchlist':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovieWatchlist()

    if action == 'moviesRelated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesRelated(actionArgs)

    if action == 'colorPicker':
        tools.colorPicker()

    if action == 'authTrakt':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().auth()

    if action == 'revokeTrakt':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().revokeAuth()

    if action == 'getSources':

        try:
            from resources.lib.gui.windows.persistent_background import PersistentBackground
            item_information = tools.get_item_information(actionArgs)

            # Assume if we couldn't get information using the normal method, that it's the legacy method
            if item_information is None:
                item_information = actionArgs

            if not tools.premium_check():
                tools.showDialog.ok(tools.addonName, tools.lang(40146),
                                    tools.lang(40147))
                return None

            if tools.playList.getposition() == 0 and tools.getSetting(
                    'general.scrapedisplay') == '0':
                display_background = True
            else:
                display_background = False

            if tools.getSetting('general.scrapedisplay') == '1':
                tools.closeBusyDialog()

            if display_background:
                background = PersistentBackground('persistent_background.xml',
                                                  tools.addonDir,
                                                  actionArgs=actionArgs)
                background.setText(tools.lang(32045))
                background.show()

            from resources.lib.modules import getSources

            uncached_sources, source_results, args = database.get(
                getSources.getSourcesHelper,
                1,
                actionArgs,
                seren_reload=seren_reload,
                seren_sources=True)
            if len(source_results) <= 0:
                tools.showDialog.notification(tools.addonName,
                                              tools.lang(32047),
                                              time=5000)
                return

            if 'showInfo' in item_information:
                source_select_style = 'Episodes'
            else:
                source_select_style = 'Movie'

            if tools.getSetting(
                    'general.playstyle%s' %
                    source_select_style) == '1' or source_select == 'true':
                try:
                    background.setText(tools.lang(40135))
                except:
                    pass

                from resources.lib.modules import sourceSelect

                stream_link = sourceSelect.sourceSelect(
                    uncached_sources, source_results, actionArgs)

                if stream_link is None:
                    tools.showDialog.notification(tools.addonName,
                                                  tools.lang(32047),
                                                  time=5000)
                    raise Exception
            else:
                try:
                    background.setText(tools.lang(32046))
                except:
                    pass

                from resources.lib.modules import resolver

                resolver_window = resolver.Resolver('resolver.xml',
                                                    tools.addonDir,
                                                    actionArgs=actionArgs)
                stream_link = database.get(resolver_window.doModal,
                                           1,
                                           source_results,
                                           args,
                                           pack_select,
                                           seren_reload=seren_reload)
                del resolver_window

                if stream_link is None:
                    tools.closeBusyDialog()
                    tools.showDialog.notification(tools.addonName,
                                                  tools.lang(32047),
                                                  time=5000)
                    raise Exception

            try:
                background.close()
            except:
                pass
            try:
                del background
            except:
                pass

            from resources.lib.modules import player

            player.serenPlayer().play_source(stream_link, actionArgs)

        except:
            # Perform cleanup and make sure all open windows close and playlist is cleared
            try:
                tools.closeBusyDialog()
            except:
                pass
            try:
                background.close()
            except:
                pass
            try:
                del background
            except:
                pass
            try:
                sources_window.close()
            except:
                pass
            try:
                del sources_window
            except:
                pass
            try:
                resolver_window.close()
            except:
                pass
            try:
                del resolver_window
            except:
                pass
            try:
                tools.playList.clear()
            except:
                pass
            try:
                tools.closeOkDialog()
            except:
                pass
            try:
                tools.cancelPlayback()
            except:
                pass

    if action == 'preScrape':
        try:
            item_information = tools.get_item_information(actionArgs)

            if 'showInfo' in item_information:
                source_select_style = 'Episodes'
            else:
                source_select_style = 'Movie'

            from resources.lib.modules import getSources

            uncached_sources, source_results, args = database.get(
                getSources.getSourcesHelper,
                1,
                actionArgs,
                seren_reload=seren_reload,
                seren_sources=True)

            if tools.getSetting('general.playstyle%s' %
                                source_select_style) == '0':
                from resources.lib.modules import resolver

                from resources.lib.modules import resolver

                resolver_window = resolver.Resolver('resolver.xml',
                                                    tools.addonDir,
                                                    actionArgs=actionArgs)
                database.get(resolver_window.doModal,
                             1,
                             source_results,
                             args,
                             pack_select,
                             seren_reload=seren_reload)

            tools.setSetting(id='general.tempSilent', value='false')
        except:
            tools.setSetting(id='general.tempSilent', value='false')
            import traceback

            traceback.print_exc()
            pass
        tools.log('Pre-scraping completed')

    if action == 'authRealDebrid':
        from resources.lib.debrid import real_debrid

        real_debrid.RealDebrid().auth()

    if action == 'showsHome':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().discoverShows()

    if action == 'myShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShows()

    if action == 'showsMyCollection':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShowCollection()

    if action == 'showsMyWatchlist':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShowWatchlist()

    if action == 'showsMyProgress':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myProgress()

    if action == 'showsMyRecentEpisodes':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myRecentEpisodes()

    if action == 'showsPopular':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsPopular(page)

    if action == 'showsRecommended':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsRecommended()

    if action == 'showsTrending':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsTrending(page)

    if action == 'showsPlayed':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsPlayed(page)

    if action == 'showsWatched':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsWatched(page)

    if action == 'showsCollected':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsCollected(page)

    if action == 'showsAnticipated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsAnticipated(page)

    if action == 'showsUpdated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsUpdated(page)

    if action == 'showsSearch':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsSearch(actionArgs)

    if action == 'showsSearchResults':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsSearchResults(actionArgs)

    if action == 'showsSearchHistory':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showSearchHistory()

    if action == 'showSeasons':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showSeasons(actionArgs)

    if action == 'seasonEpisodes':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().seasonEpisodes(actionArgs)

    if action == 'showsRelated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsRelated(actionArgs)

    if action == 'showYears':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().showYears(actionArgs, page)

    if action == 'searchMenu':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().searchMenu()

    if action == 'toolsMenu':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().toolsMenu()

    if action == 'clearCache':
        from resources.lib.common import tools

        tools.clearCache()

    if action == 'traktManager':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().traktManager(actionArgs)

    if action == 'onDeckShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().onDeckShows()

    if action == 'onDeckMovies':
        from resources.lib.gui.movieMenus import Menus

        Menus().onDeckMovies()

    if action == 'cacheAssist':
        from resources.lib.modules import cacheAssist

        cacheAssist.CacheAssit(actionArgs)

    if action == 'tvGenres':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showGenres()

    if action == 'showGenresGet':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showGenreList(actionArgs, page)

    if action == 'movieGenres':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieGenres()

    if action == 'movieGenresGet':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieGenresList(actionArgs, page)

    if action == 'filePicker':
        from resources.lib.modules import smartPlay

        smartPlay.SmartPlay(actionArgs).torrent_file_picker()

    if action == 'shufflePlay':
        from resources.lib.modules import smartPlay

        try:
            smart = smartPlay.SmartPlay(actionArgs).shufflePlay()
        except:
            import traceback
            traceback.print_exc()
            pass

    if action == 'resetSilent':
        tools.setSetting('general.tempSilent', 'false')
        tools.showDialog.notification(tools.addonName + ": Silent scrape",
                                      tools.lang(32048),
                                      time=5000)

    if action == 'clearTorrentCache':
        from resources.lib.modules import database

        database.torrent_cache_clear()

    if action == 'openSettings':
        tools.execute('Addon.OpenSettings(%s)' % tools.addonInfo('id'))

    if action == 'myTraktLists':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().myTraktLists(actionArgs)

    if action == 'traktList':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().getListItems(actionArgs, page)

    if action == 'nonActiveAssistClear':
        from resources.lib.gui import debridServices

        debridServices.Menus().assist_non_active_clear()

    if action == 'debridServices':
        from resources.lib.gui import debridServices

        debridServices.Menus().home()

    if action == 'cacheAssistStatus':
        from resources.lib.gui import debridServices

        debridServices.Menus().get_assist_torrents()

    if action == 'premiumizeTransfers':
        from resources.lib.gui import debridServices

        debridServices.Menus().list_premiumize_transfers()

    if action == 'showsNextUp':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myNextUp()

    if action == 'runMaintenance':
        from resources.lib.common import maintenance

        maintenance.run_maintenance()

    if action == 'providerTools':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().providerMenu()

    if action == 'adjustProviders':
        from resources.lib.modules import customProviders

        customProviders.providers().adjust_providers(actionArgs)

    if action == 'adjustPackage':
        from resources.lib.modules import customProviders

        customProviders.providers().adjust_providers(actionArgs,
                                                     package_disable=True)

    if action == 'installProviders':
        from resources.lib.modules import customProviders

        customProviders.providers().install_package(actionArgs)

    if action == 'uninstallProviders':
        from resources.lib.modules import customProviders

        customProviders.providers().uninstall_package()

    if action == 'showsNew':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().newShows()

    if action == 'realdebridTransfers':
        from resources.lib.gui import debridServices

        debridServices.Menus().list_RD_transfers()

    if action == 'cleanInstall':
        from resources.lib.common import maintenance

        maintenance.wipe_install()

    if action == 'buildPlaylistWorkaround':

        from resources.lib.modules import smartPlay
        smartPlay.SmartPlay(actionArgs).resume_playback()

    if action == 'premiumizeCleanup':
        from resources.lib.common import maintenance

        maintenance.premiumize_transfer_cleanup()

    if action == 'test2':
        tools.log('Nope')

    if action == 'manualProviderUpdate':
        from resources.lib.modules import customProviders

        customProviders.providers().manual_update()

    if action == 'clearSearchHistory':
        from resources.lib.modules import database

        database.clearSearchHistory()
        tools.showDialog.ok(tools.addonName, 'Search History has been cleared')

    if action == 'externalProviderInstall':
        from resources.lib.modules import customProviders

        confirmation = tools.showDialog.yesno(tools.addonName,
                                              tools.lang(40117))
        if confirmation == 0:
            sys.exit()

        customProviders.providers().install_package(1, url=url)

    if action == 'externalProviderUninstall':
        from resources.lib.modules import customProviders

        confirmation = tools.showDialog.yesno(tools.addonName,
                                              tools.lang(40119) % url)
        if confirmation == 0:
            sys.exit()

        customProviders.providers().uninstall_package(package=url,
                                                      silent=False)

    if action == 'showsNetworks':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsNetworks()

    if action == 'showsNetworkShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsNetworkShows(actionArgs, page)

    if action == 'movieYears':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieYears()

    if action == 'movieYearsMovies':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieYearsMovies(actionArgs, page)

    if action == 'syncTraktActivities':
        from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
        TraktSyncDatabase().sync_activities()

    if action == 'traktSyncTools':
        from resources.lib.gui import homeMenu
        homeMenu.Menus().traktSyncTools()

    if action == 'flushTraktActivities':
        from resources.lib.modules import trakt_sync
        trakt_sync.TraktSyncDatabase().flush_activities()

    if action == 'flushTraktDBMeta':
        from resources.lib.modules import trakt_sync
        trakt_sync.TraktSyncDatabase().clear_all_meta()

    if action == 'myFiles':
        from resources.lib.gui import myFiles
        myFiles.Menus().home()

    if action == 'myFilesFolder':
        from resources.lib.gui import myFiles
        myFiles.Menus().myFilesFolder(actionArgs)

    if action == 'myFilesPlay':
        from resources.lib.gui import myFiles
        myFiles.Menus().myFilesPlay(actionArgs)

    if action == 'forceTraktSync':
        from resources.lib.modules import trakt_sync
        from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
        trakt_sync.TraktSyncDatabase().flush_activities()
        TraktSyncDatabase().sync_activities()

    if action == 'rebuildTraktDatabase':
        from resources.lib.modules.trakt_sync import TraktSyncDatabase
        TraktSyncDatabase().re_build_database()

    if action == 'myUpcomingEpisodes':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().myUpcomingEpisodes()

    if action == 'showsByActor':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().showsByActor(actionArgs)

    if action == 'movieByActor':
        from resources.lib.gui import movieMenus
        movieMenus.Menus().moviesByActor(actionArgs)

    if action == 'playFromRandomPoint':
        from resources.lib.modules import smartPlay
        smartPlay.SmartPlay(actionArgs).play_from_random_point()

    if action == 'refreshProviders':
        from resources.lib.modules.customProviders import providers
        providers().update_known_providers()

    if unit_tests:
        items = tools.xbmcplugin.DIRECTORY.items
        tools.xbmcplugin.DIRECTORY.items = []
        return items
コード例 #4
0
def dispatch(params):
    from resources.lib.common import tools
    from resources.lib.modules import database

    tools.SETTINGS_CACHE = {}

    try:

        url = params.get('url')

        action = params.get('action')

        page = params.get('page')

        actionArgs = params.get('actionArgs')

        pack_select = params.get('packSelect')

        source_select = params.get('source_select')

        seren_reload = True if params.get('seren_reload') == 'true' else False

        resume = params.get('resume')

        forceresumeoff = True if params.get(
            'forceresumeoff') == 'true' else False

        forceresumeon = True if params.get(
            'forceresumeon') == 'true' else False

        smartPlay = True if params.get('smartPlay') == 'true' else False

    except:

        print('Welcome to console mode')
        print('Command Help:')
        print('   - Menu Number: opens the relevant menu page')
        print('   - shell: opens a interactive python shell within Seren')
        print('   - action xxx: run a custom Seren URL argument')

        url = ''

        action = None

        page = ''

        actionArgs = ''

        pack_select = ''

        source_select = ''

        seren_reload = ''

        resume = None

        forceresumeoff = True if params.get(
            'forceresumeoff') == 'true' else False

        forceresumeon = True if params.get(
            'forceresumeon') == 'true' else False

        smartPlay = True if params.get('smartPlay') == 'true' else False

    tools.log('Seren, Running Path - Action: %s, actionArgs: %s' %
              (action, actionArgs))

    if action is None:
        from resources.lib.gui import homeMenu

        homeMenu.Menus().home()

    if action == 'smartPlay':
        from resources.lib.modules import smartPlay
        # if 'resume' not in actionArgs:
        #     actionArgs = json.loads(actionArgs)
        #     actionArgs['resume'] = sys.argv[3].split(':')[-1]
        #     actionArgs = tools.quote(json.dumps(actionArgs, sort_keys=True))
        smartPlay.SmartPlay(actionArgs).fill_playlist()

    if action == 'playbackResume':
        from resources.lib.modules import smartPlay
        smart = smartPlay.SmartPlay(actionArgs)
        smart.workaround()

    if action == 'moviesHome':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().discoverMovies()

    if action == 'moviesPopular':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesPopular(page)

    if action == 'moviesTrending':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesTrending(page)

    if action == 'moviesPlayed':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesPlayed(page)

    if action == 'moviesWatched':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesWatched(page)

    if action == 'moviesCollected':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesCollected(page)

    if action == 'moviesAnticipated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesAnticipated(page)

    if action == 'moviesBoxOffice':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesBoxOffice()

    if action == 'moviesUpdated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesUpdated(page)

    if action == 'moviesRecommended':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesRecommended()

    if action == 'moviesSearch':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearch(actionArgs)

    if action == 'moviesSearchResults':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearchResults(actionArgs)

    if action == 'moviesSearchHistory':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesSearchHistory()

    if action == 'myMovies':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovies()

    if action == 'moviesMyCollection':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovieCollection()

    if action == 'moviesMyWatchlist':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().myMovieWatchlist()

    if action == 'moviesRelated':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().moviesRelated(actionArgs)

    if action == 'colorPicker':
        tools.colorPicker()

    if action == 'authTrakt':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().auth()

    if action == 'revokeTrakt':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().revokeAuth()

    if action == 'getSources':

        try:

            item_information = tools.get_item_information(actionArgs)
            #
            # This tomfoolery here is the new workaround for Seren to skip the building playlist window

            if tools.getSetting(
                    'smartplay.playlistcreate') == 'true' or smartPlay:

                if tools.playList.size() > 0:
                    playlist_uris = [
                        tools.playList[i].getPath()
                        for i in range(tools.playList.size())
                    ]
                else:
                    playlist_uris = []

                if ('showInfo' in item_information and tools.playList.size() == 0) \
                        or not any(sys.argv[2] in i for i in playlist_uris):

                    try:
                        name = item_information['info']['title']
                        item = tools.addDirectoryItem(
                            name,
                            'getSources',
                            item_information['info'],
                            item_information['art'],
                            item_information['cast'],
                            isFolder=False,
                            isPlayable=True,
                            actionArgs=actionArgs,
                            bulk_add=True,
                            set_ids=item_information['ids'])
                        tools.cancelPlayback()
                        tools.playList.add(url=sys.argv[0] + sys.argv[2],
                                           listitem=item[1])
                        tools.player().play(tools.playList)
                        return
                    except:
                        import traceback
                        traceback.print_exc()
                        return

            bookmark_style = tools.getSetting('general.bookmarkstyle')

            if tools.playList.size(
            ) == 1 and resume is not None and bookmark_style != '2' and not forceresumeoff:

                if bookmark_style == '0' and not forceresumeon:
                    import datetime
                    selection = tools.showDialog.contextmenu([
                        '{} {}'.format(
                            tools.lang(32092),
                            datetime.timedelta(seconds=int(resume))),
                        tools.lang(40350)
                    ])
                    if selection == -1:
                        tools.cancelPlayback()
                        sys.exit()
                    elif selection != 0:
                        resume = None
            else:
                resume = None

            # Assume if we couldn't get information using the normal method, that it's the legacy method
            if item_information is None:
                item_information = actionArgs

            if not tools.premium_check():
                tools.showDialog.ok(tools.addonName, tools.lang(40146),
                                    tools.lang(40147))
                return None

            if tools.playList.getposition() == 0 and tools.getSetting(
                    'general.scrapedisplay') == '0':
                display_background = True
            else:
                display_background = False

            from resources.lib.modules.skin_manager import SkinManager

            if display_background:
                from resources.lib.gui.windows.persistent_background import PersistentBackground
                background = PersistentBackground(
                    *SkinManager().confirm_skin_path(
                        'persistent_background.xml'),
                    actionArgs=actionArgs)
                background.setText(tools.lang(32045))
                background.show()

            from resources.lib.modules import getSources

            uncached_sources, source_results, args = database.get(
                getSources.getSourcesHelper,
                1,
                actionArgs,
                seren_reload=seren_reload,
                seren_sources=True)
            if len(source_results) <= 0:
                tools.showDialog.notification(tools.addonName,
                                              tools.lang(32047),
                                              time=5000)
                return

            if 'showInfo' in item_information:
                source_select_style = 'Episodes'
            else:
                source_select_style = 'Movie'

            if tools.getSetting(
                    'general.playstyle%s' %
                    source_select_style) == '1' or source_select == 'true':

                try:
                    background.setText(tools.lang(40135))
                except:
                    pass

                from resources.lib.modules import sourceSelect

                stream_link = sourceSelect.sourceSelect(
                    uncached_sources, source_results, actionArgs)

                if stream_link is None:
                    tools.showDialog.notification(tools.addonName,
                                                  tools.lang(32047),
                                                  time=5000)
                    raise Exception
                if not stream_link:
                    # user has backed out of source select, don't show no playable sources notification
                    raise Exception
            else:
                try:
                    background.setText(tools.lang(32046))
                except:
                    pass

                from resources.lib.modules import resolver

                resolver_window = resolver.Resolver(
                    *SkinManager().confirm_skin_path('resolver.xml'),
                    actionArgs=actionArgs)

                stream_link = database.get(resolver_window.doModal,
                                           1,
                                           source_results,
                                           args,
                                           pack_select,
                                           seren_reload=seren_reload)
                del resolver_window

                if stream_link is None:
                    tools.closeBusyDialog()
                    tools.showDialog.notification(tools.addonName,
                                                  tools.lang(32047),
                                                  time=5000)
                    raise Exception

            tools.showBusyDialog()
            try:
                background.close()
            except:
                pass
            try:
                del background
            except:
                pass

            from resources.lib.modules import player

            # if 'resume' not in actionArgs:
            #     actionArgs = json.loads(actionArgs)
            #     actionArgs['resume'] = sys.argv[3].split(':')[-1]
            #     actionArgs = json.dumps(actionArgs, sort_keys=True)

            player.serenPlayer().play_source(stream_link,
                                             actionArgs,
                                             resume_time=resume,
                                             params=params)

        except:
            import traceback
            traceback.print_exc()
            # Perform cleanup and make sure all open windows close and playlist is cleared
            try:
                tools.closeBusyDialog()
            except:
                pass
            try:
                background.close()
            except:
                pass
            try:
                del background
            except:
                pass
            try:
                resolver_window.close()
            except:
                pass
            try:
                del resolver_window
            except:
                pass
            try:
                tools.playList.clear()
            except:
                pass
            try:
                tools.closeOkDialog()
            except:
                pass
            try:
                tools.cancelPlayback()
            except:
                pass

    if action == 'preScrape':

        from resources.lib.modules.skin_manager import SkinManager

        try:
            item_information = tools.get_item_information(actionArgs)

            if 'showInfo' in item_information:
                source_select_style = 'Episodes'
            else:
                source_select_style = 'Movie'

            from resources.lib.modules import getSources

            uncached_sources, source_results, args = database.get(
                getSources.getSourcesHelper,
                1,
                actionArgs,
                seren_reload=seren_reload,
                seren_sources=True)

            if tools.getSetting('general.playstyle%s' %
                                source_select_style) == '0':
                from resources.lib.modules import resolver

                resolver_window = resolver.Resolver(
                    *SkinManager().confirm_skin_path('resolver.xml'),
                    actionArgs=actionArgs)
                database.get(resolver_window.doModal,
                             1,
                             source_results,
                             args,
                             pack_select,
                             seren_reload=seren_reload)

            tools.setSetting(id='general.tempSilent', value='false')
        except:
            tools.setSetting(id='general.tempSilent', value='false')
            import traceback

            traceback.print_exc()
            pass

        tools.log('Pre-scraping completed')

    if action == 'authRealDebrid':
        from resources.lib.debrid import real_debrid

        real_debrid.RealDebrid().auth()

    if action == 'showsHome':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().discoverShows()

    if action == 'myShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShows()

    if action == 'showsMyCollection':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShowCollection()

    if action == 'showsMyWatchlist':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myShowWatchlist()

    if action == 'showsMyProgress':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myProgress()

    if action == 'showsMyRecentEpisodes':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myRecentEpisodes()

    if action == 'showsPopular':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsPopular(page)

    if action == 'showsRecommended':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsRecommended()

    if action == 'showsTrending':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsTrending(page)

    if action == 'showsPlayed':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsPlayed(page)

    if action == 'showsWatched':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsWatched(page)

    if action == 'showsCollected':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsCollected(page)

    if action == 'showsAnticipated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsAnticipated(page)

    if action == 'showsUpdated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsUpdated(page)

    if action == 'showsSearch':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsSearch(actionArgs)

    if action == 'showsSearchResults':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsSearchResults(actionArgs)

    if action == 'showsSearchHistory':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showSearchHistory()

    if action == 'showSeasons':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showSeasons(actionArgs)

    if action == 'seasonEpisodes':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().seasonEpisodes(actionArgs)

    if action == 'showsRelated':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsRelated(actionArgs)

    if action == 'showYears':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().showYears(actionArgs, page)

    if action == 'searchMenu':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().searchMenu()

    if action == 'toolsMenu':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().toolsMenu()

    if action == 'clearCache':
        from resources.lib.common import tools

        tools.clearCache()

    if action == 'traktManager':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().traktManager(actionArgs)

    if action == 'onDeckShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().onDeckShows()

    if action == 'onDeckMovies':
        from resources.lib.gui.movieMenus import Menus

        Menus().onDeckMovies()

    if action == 'cacheAssist':
        from resources.lib.modules import cacheAssist

        cacheAssist.CacheAssit(actionArgs)

    if action == 'tvGenres':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showGenres()

    if action == 'showGenresGet':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showGenreList(actionArgs, page)

    if action == 'movieGenres':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieGenres()

    if action == 'movieGenresGet':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieGenresList(actionArgs, page)

    if action == 'filePicker':
        from resources.lib.modules import smartPlay

        smartPlay.SmartPlay(actionArgs).torrent_file_picker()

    if action == 'shufflePlay':
        from resources.lib.modules import smartPlay

        try:
            smart = smartPlay.SmartPlay(actionArgs).shufflePlay()
        except:
            import traceback
            traceback.print_exc()
            pass

    if action == 'resetSilent':
        tools.setSetting('general.tempSilent', 'false')
        tools.showDialog.notification('{}: {}'.format(tools.addonName,
                                                      tools.lang(40296)),
                                      tools.lang(32048),
                                      time=5000)

    if action == 'clearTorrentCache':
        from resources.lib.modules import database

        database.torrent_cache_clear()

    if action == 'openSettings':
        tools.execute('Addon.OpenSettings(%s)' % tools.addonInfo('id'))

    if action == 'myTraktLists':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().myTraktLists(actionArgs)

    if action == 'traktList':
        from resources.lib.indexers import trakt

        trakt.TraktAPI().getListItems(actionArgs, page)

    if action == 'nonActiveAssistClear':
        from resources.lib.gui import debridServices

        debridServices.Menus().assist_non_active_clear()

    if action == 'debridServices':
        from resources.lib.gui import debridServices

        debridServices.Menus().home()

    if action == 'cacheAssistStatus':
        from resources.lib.gui import debridServices

        debridServices.Menus().get_assist_torrents()

    if action == 'premiumizeTransfers':
        from resources.lib.gui import debridServices

        debridServices.Menus().list_premiumize_transfers()

    if action == 'showsNextUp':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().myNextUp()

    if action == 'runMaintenance':
        from resources.lib.common import maintenance

        maintenance.run_maintenance()

    if action == 'providerTools':
        from resources.lib.gui import homeMenu

        homeMenu.Menus().providerMenu()

    if action == 'adjustProviders':
        tools.log('adjustProviders endpoint has been deprecated')
        return
        # from resources.lib.modules import customProviders
        #
        # customProviders.providers().adjust_providers(actionArgs)

    if action == 'adjustPackage':
        tools.log('adjustPackage endpoint has been deprecated')
        return
        # DEPRECATED
        # from resources.lib.modules import customProviders
        #
        # customProviders.providers().adjust_providers(actionArgs, package_disable=True)

    if action == 'installProviders':
        from resources.lib.modules import customProviders

        customProviders.providers().install_package(actionArgs)

    if action == 'uninstallProviders':
        from resources.lib.modules import customProviders

        customProviders.providers().uninstall_package()

    if action == 'showsNew':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().newShows()

    if action == 'realdebridTransfers':
        from resources.lib.gui import debridServices

        debridServices.Menus().list_RD_transfers()

    if action == 'cleanInstall':
        from resources.lib.common import maintenance

        maintenance.wipe_install()

    if action == 'buildPlaylistWorkaround':
        from resources.lib.modules import smartPlay
        smartPlay.SmartPlay(actionArgs).resume_playback()

    if action == 'premiumizeCleanup':
        from resources.lib.common import maintenance

        maintenance.premiumize_transfer_cleanup()

    if action == 'test2':
        pass

    if action == 'manualProviderUpdate':
        from resources.lib.modules import customProviders

        customProviders.providers().manual_update()

    if action == 'clearSearchHistory':
        from resources.lib.modules import database

        database.clearSearchHistory()

    if action == 'externalProviderInstall':
        from resources.lib.modules import customProviders

        confirmation = tools.showDialog.yesno(tools.addonName,
                                              tools.lang(40117))
        if confirmation == 0:
            sys.exit()

        customProviders.providers().install_package(1, url=url)

    if action == 'externalProviderUninstall':
        from resources.lib.modules import customProviders

        confirmation = tools.showDialog.yesno(tools.addonName,
                                              tools.lang(40119) % url)
        if confirmation == 0:
            sys.exit()

        customProviders.providers().uninstall_package(package=url,
                                                      silent=False)

    if action == 'showsNetworks':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsNetworks()

    if action == 'showsNetworkShows':
        from resources.lib.gui import tvshowMenus

        tvshowMenus.Menus().showsNetworkShows(actionArgs, page)

    if action == 'movieYears':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieYears()

    if action == 'movieYearsMovies':
        from resources.lib.gui import movieMenus

        movieMenus.Menus().movieYearsMovies(actionArgs, page)

    if action == 'syncTraktActivities':
        from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
        TraktSyncDatabase().sync_activities()

    if action == 'traktSyncTools':
        from resources.lib.gui import homeMenu
        homeMenu.Menus().traktSyncTools()

    if action == 'flushTraktActivities':
        from resources.lib.modules import trakt_sync
        trakt_sync.TraktSyncDatabase().flush_activities()

    if action == 'flushTraktDBMeta':
        from resources.lib.modules import trakt_sync
        trakt_sync.TraktSyncDatabase().clear_all_meta()

    if action == 'myFiles':
        from resources.lib.gui import myFiles
        myFiles.Menus().home()

    if action == 'myFilesFolder':
        from resources.lib.gui import myFiles
        myFiles.Menus().myFilesFolder(actionArgs)

    if action == 'myFilesPlay':
        from resources.lib.gui import myFiles
        myFiles.Menus().myFilesPlay(actionArgs)

    if action == 'forceTraktSync':
        from resources.lib.modules import trakt_sync
        from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
        trakt_sync.TraktSyncDatabase().flush_activities()
        TraktSyncDatabase().sync_activities()

    if action == 'rebuildTraktDatabase':
        from resources.lib.modules.trakt_sync import TraktSyncDatabase
        TraktSyncDatabase().re_build_database()

    if action == 'myUpcomingEpisodes':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().myUpcomingEpisodes()

    if action == 'myWatchedEpisodes':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().myWatchedEpisodes(page)

    if action == 'myWatchedMovies':
        from resources.lib.gui import movieMenus
        movieMenus.Menus().myWatchedMovies(page)

    if action == 'showsByActor':
        from resources.lib.gui import tvshowMenus
        tvshowMenus.Menus().showsByActor(actionArgs)

    if action == 'movieByActor':
        from resources.lib.gui import movieMenus
        movieMenus.Menus().moviesByActor(actionArgs)

    if action == 'playFromRandomPoint':
        from resources.lib.modules import smartPlay
        smartPlay.SmartPlay(actionArgs).play_from_random_point()

    if action == 'refreshProviders':
        from resources.lib.modules.customProviders import providers
        providers().update_known_providers()

    if action == 'installSkin':
        from resources.lib.modules.skin_manager import SkinManager
        SkinManager().install_skin()

    if action == 'uninstallSkin':
        from resources.lib.modules.skin_manager import SkinManager
        SkinManager().uninstall_skin()

    if action == 'switchSkin':
        from resources.lib.modules.skin_manager import SkinManager
        SkinManager().switch_skin()

    if action == 'manageProviders':
        tools.showBusyDialog()
        from resources.lib.gui.windows.custom_providers import CustomProviders
        from resources.lib.modules.skin_manager import SkinManager
        CustomProviders(*SkinManager().confirm_skin_path(
            'custom_providers.xml')).doModal()

    if action == 'flatEpisodes':
        from resources.lib.gui.tvshowMenus import Menus
        Menus().flat_episode_list(actionArgs)

    if action == 'runPlayerDialogs':
        from resources.lib.modules.player import PlayerDialogs
        try:
            PlayerDialogs().display_dialog()
        except:
            import traceback
            traceback.print_exc()

    if action == 'authAllDebrid':
        from resources.lib.debrid.all_debrid import AllDebrid
        AllDebrid().auth()

    if action == 'checkSkinUpdates':
        from resources.lib.modules.skin_manager import SkinManager
        SkinManager().check_for_updates()

    if action == 'authPremiumize':
        from resources.lib.debrid.premiumize import Premiumize
        Premiumize().auth()