def re_build_database(self, silent=False): if not silent: confirm = xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30201)) if confirm == 0: return self.clear_all_meta(False) self.clear_user_information(False) self.rebuild_database() self.set_base_activities() self.refresh_activities() from resources.lib.database.trakt_sync import activities sync_errors = activities.TraktSyncDatabase().sync_activities(silent) if sync_errors: g.notification(self.notification_prefix, g.get_language_string(30364), time=5000) elif sync_errors is None: self.refresh_activities() else: g.notification(self.notification_prefix, g.get_language_string(30299), time=5000)
def update(self, meta_file, silent=False): """ Request the upate of a installed package :param meta_file: Contents of provider packages meta file :type meta_file: dict :param silent: optional disabling of user feedback :type silent: bool :return: None :rtype: None """ self.silent = silent update_directory = meta_file["update_directory"] package_name = meta_file["name"] version = meta_file["version"] zip_file = "{}{}-{}.zip".format(update_directory, package_name, version) try: self._get_zip_file(url=zip_file, silent=True) except requests.exceptions.ConnectionError: g.close_busy_dialog() xbmcgui.Dialog().ok(g.ADDON_NAME, g.get_language_string(30078)) return result = self._install_zip() if result is not None: g.notification(g.ADDON_NAME, g.get_language_string(30080).format(package_name))
def clear_user_information(self, notify=True): username = self.activities["trakt_username"] self.execute_sql( [ "UPDATE episodes SET watched=?", "UPDATE episodes SET collected=?", "UPDATE movies SET watched=?", "UPDATE movies SET collected=?", "UPDATE shows SET unwatched_episodes=?", "UPDATE shows SET watched_episodes=?", "UPDATE seasons SET unwatched_episodes=?", "UPDATE seasons SET watched_episodes=?", ], (0, ), ) self.execute_sql( [ "UPDATE episodes SET last_watched_at=?", "UPDATE movies SET last_watched_at=?", ], (None, ), ) self.execute_sql([ "DELETE from bookmarks WHERE 1=1", "DELETE from hidden WHERE 1=1", ]) self.execute_sql("DELETE from lists WHERE username=?", (username, )) self.set_trakt_user("") self.set_base_activities() if notify: g.notification(self.notification_prefix, g.get_language_string(30297), time=5000)
def clear_all_meta(self, notify=True): if notify: confirm = xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30201)) if confirm == 0: return self.execute_sql( [ "UPDATE shows SET info=?, cast=?, art=?, meta_hash=?", "UPDATE seasons SET info=?, cast=?, art=?, meta_hash=?", "UPDATE episodes SET info=?, cast=?, art=?, meta_hash=?", "UPDATE movies SET info=?, cast=?, art=?, meta_hash=?", ], (None, None, None, None), ) self.execute_sql([ "DELETE FROM movies_meta", "DELETE FROM shows_meta", "DELETE FROM seasons_meta", "DELETE FROM episodes_meta", ]) if notify: g.notification(self.notification_prefix, g.get_language_string(30298), time=5000)
def _error_handler(request): if request.json().get("status") == "error": message = "Premiumize API error: {}".format( request.json().get("message")) g.notification(g.ADDON_NAME, message) g.log(message, "error") return request
def _remove_playback_history(self, item_information): media_type = "movie" if item_information["mediatype"] != "movie": media_type = "episode" progress = self.trakt_api.get_json( "sync/playback/{}".format(media_type + "s")) if len(progress) == 0: return if media_type == "movie": progress_ids = [ i["playback_id"] for i in progress if i["trakt_id"] == item_information["trakt_id"] ] else: progress_ids = [ i["playback_id"] for i in progress if i["episode"]["trakt_id"] == item_information["trakt_id"] ] for i in progress_ids: self.trakt_api.delete_request("sync/playback/{}".format(i)) from resources.lib.database.trakt_sync.bookmark import TraktSyncDatabase TraktSyncDatabase().remove_bookmark(item_information["trakt_id"]) g.container_refresh() g.notification(g.ADDON_NAME, g.get_language_string(30301)) g.trigger_widget_refresh()
def try_refresh_token(self, force=False): if not self.refresh: return if not force and self.expiry > float(time.time()): return try: with GlobalLock(self.__class__.__name__, True, self.token): url = self.oauth_url + "token" response = self.session.post( url, data={ "grant_type": "http://oauth.net/grant_type/device/1.0", "code": self.refresh, "client_secret": self.client_secret, "client_id": self.client_id, }, ) if not self._is_response_ok(response): response = response.json() g.notification( g.ADDON_NAME, "Failed to refresh RD token, please manually re-auth" ) g.log("RD Refresh error: {}".format(response["error"])) g.log( "Invalid response from Real Debrid - {}".format(response), "error" ) return False response = response.json() self._save_settings(response) g.log("Real Debrid Token Refreshed") return True except RanOnceAlready: self._load_settings() return
def _init_providers(self): sys.path.append(g.ADDON_USERDATA_PATH) try: if g.ADDON_USERDATA_PATH not in sys.path: sys.path.append(g.ADDON_USERDATA_PATH) providers = importlib.import_module("providers") else: providers = reload_module(importlib.import_module("providers")) except ValueError: g.notification(g.ADDON_NAME, g.get_language_string(30465)) g.log('No providers installed', 'warning') return providers_dict = providers.get_relevant(self.language) torrent_providers = providers_dict['torrent'] hoster_providers = providers_dict['hosters'] adaptive_providers = providers_dict['adaptive'] hoster_providers, torrent_providers = self._remove_duplicate_providers(torrent_providers, hoster_providers) self.hoster_domains = resolver.Resolver.get_hoster_list() self.torrent_providers = torrent_providers self.hoster_providers = hoster_providers self.adaptive_providers = adaptive_providers self.host_domains = OrderedDict.fromkeys([host[0].lower() for provider in self.hoster_domains['premium'] for host in self.hoster_domains['premium'][provider]]) self.host_names = OrderedDict.fromkeys([host[1].lower() for provider in self.hoster_domains['premium'] for host in self.hoster_domains['premium'][provider]])
def source_select(uncached_sources, source_list, item_information): selection = None try: if len(source_list) == 0 and len(uncached_sources) == 0: return None from resources.lib.gui.windows.source_select import SourceSelect selection = None try: window = SourceSelect( *SkinManager().confirm_skin_path("source_select.xml"), item_information=item_information, sources=source_list, uncached=uncached_sources) selection = window.doModal() finally: del window if selection is None: g.notification(g.ADDON_NAME, g.get_language_string(30032), time=5000) raise Exception if not selection: g.cancel_playback() finally: return selection
def _add_to_watchlist(self, item_information): self.trakt_api.post("sync/watchlist", self._info_to_trakt_object(item_information, True)) g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30286)), g.get_language_string(30292), ) g.trigger_widget_refresh()
def _check_for_first_run(self, silent, trakt_auth): if (not silent and str(self.activities["all_activities"]) == self.base_date and trakt_auth is not None): g.notification(g.ADDON_NAME, g.get_language_string(30197)) # Give the people time to read the damn notification xbmc.sleep(500) self.silent = False self.progress_dialog = xbmcgui.DialogProgressBG() self.progress_dialog.create(g.ADDON_NAME + "Sync", "newf: Trakt Sync")
def _confirm_marked_unwatched(response, type): if response["deleted"][type] > 0: return True else: g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30286)), g.get_language_string(30287), ) g.log( "Failed to mark item as unwatched\nTrakt Response: {}".format( response)) return False
def _resolve_item(self, pack_select): if g.get_bool_setting('general.autotrynext') and not pack_select: sources = self.sources[self.position:] else: sources = [self.sources[self.position]] self.stream_link = Resolverhelper().resolve_silent_or_visible(sources, self.item_information, pack_select, overwrite_cache=pack_select) if self.stream_link is None: g.notification(g.ADDON_NAME, g.get_language_string(30033), time=2000) else: self.close()
def display_expiry_notification(display_debrid_name): """ Ease of use method to notify user of expiry of debrid premium status :param display_debrid_name: Debrid providers full display name :type display_debrid_name: str :return: None :rtype: None """ if g.get_bool_setting("general.accountNotifications"): g.notification( "{}".format(g.ADDON_NAME), g.get_language_string(30036).format(display_debrid_name), )
def update_provider_packages(): """ Perform checks for provider package updates :return: None :rtype: None """ provider_check_stamp = g.get_float_setting("provider.updateCheckTimeStamp", 0) automatic = g.get_bool_setting("providers.autoupdates") if time.time() > (provider_check_stamp + (24 * (60 * 60))): available_updates = ProviderInstallManager().check_for_updates( silent=True, automatic=automatic) if not automatic and len(available_updates) > 0: g.notification(g.ADDON_NAME, g.get_language_string(30278)) g.set_setting("provider.updateCheckTimeStamp", str(time.time()))
def get_sources(self, action_args, overwrite_cache=None): """ Method to handle automatic background or foreground scraping :param action_args: action arguments from request uri :param overwrite_cache: Set to true if you wish to overwrite the current cached return value :return: """ item_information = tools.get_item_information(action_args) if not ProviderCache().get_provider_packages(): yesno = xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30465)) if not yesno: return sources = Sources(item_information).get_sources() if sources is None or len(sources) <= 0 or len(sources[1]) <= 0: g.cancel_playback() g.notification(g.ADDON_NAME, g.get_language_string(30032), time=5000) return sources
def sort_sources(self, item_information, sources_list): """ Method to handle source filtering, sorting and notifications :param item_information: The item information :type item_information: dict :param sources_list: the list of sources to be sorted :type sources_list list :return: Filtered and Sorted sources :rtype: list """ sources = SourceSorter(item_information).sort_sources(sources_list) if sources is None or len(sources) < 1: g.cancel_playback() g.notification(g.ADDON_NAME, g.get_language_string(30032), time=5000) return return sources
def _mark_unwatched(self, item_information): response = self.trakt_api.post_json( "sync/history/remove", self._info_to_trakt_object(item_information)) if item_information["mediatype"] == "movie": from resources.lib.database.trakt_sync.movies import TraktSyncDatabase if not self._confirm_marked_unwatched(response, "movies"): return TraktSyncDatabase().mark_movie_unwatched( item_information["trakt_id"]) else: from resources.lib.database.trakt_sync.shows import TraktSyncDatabase if not self._confirm_marked_unwatched(response, "episodes"): return if item_information["mediatype"] == "episode": TraktSyncDatabase().mark_episode_unwatched( item_information["trakt_show_id"], item_information["season"], item_information["episode"], ) elif item_information["mediatype"] == "season": show_id = item_information["trakt_show_id"] season_no = item_information["season"] TraktSyncDatabase().mark_season_watched(show_id, season_no, 0) elif item_information["mediatype"] == "tvshow": TraktSyncDatabase().mark_show_watched( item_information["trakt_id"], 0) from resources.lib.database.trakt_sync.bookmark import TraktSyncDatabase TraktSyncDatabase().remove_bookmark(item_information["trakt_id"]) g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30286)), g.get_language_string(30289), ) g.container_refresh() g.trigger_widget_refresh()
def _add_to_collection(self, item_information): self.trakt_api.post("sync/collection", self._info_to_trakt_object(item_information, True)) if item_information["mediatype"] == "movie": from resources.lib.database.trakt_sync.movies import TraktSyncDatabase TraktSyncDatabase().mark_movie_collected( item_information["trakt_id"]) else: from resources.lib.database.trakt_sync.shows import TraktSyncDatabase trakt_id = self._get_show_id(item_information) TraktSyncDatabase().mark_show_collected(trakt_id, 1) g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30286)), g.get_language_string(30290), ) g.trigger_widget_refresh()
def _finalise_results(self): monkey_requests.allow_provider_requests = False self._send_provider_stop_event() uncached = [i for i in self.sources_information["allTorrents"].values() if i['hash'] not in self.sources_information['cached_hashes']] if not self._is_playable_source(): self._build_cache_assist() g.cancel_playback() if self.silent: g.notification(g.ADDON_NAME, g.get_language_string(30055)) return uncached, [], self.item_information sorted_sources = SourceSorter(self.media_type).sort_sources( list(self.sources_information["torrentCacheSources"].values()), list(self.sources_information['hosterSources'].values()), self.sources_information['cloudFiles']) sorted_sources = self.sources_information['adaptiveSources'] + sorted_sources return uncached, sorted_sources, self.item_information
def _hide_item(self, item_information): from resources.lib.database.trakt_sync.hidden import TraktSyncDatabase if item_information['mediatype'] == "movie": section = "calendar" sections_display = [g.get_language_string(30298)] selection = 0 else: sections = ["progress_watched", "calendar"] sections_display = [ g.get_language_string(30297), g.get_language_string(30298) ] selection = xbmcgui.Dialog().select( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30299)), sections_display, ) if selection == -1: return section = sections[selection] self.trakt_api.post_json( "users/hidden/{}".format(section), self._info_to_trakt_object(item_information, True), ) if item_information['mediatype'] == "movie": TraktSyncDatabase().add_hidden_item(item_information['trakt_id'], "movie", section) else: TraktSyncDatabase().add_hidden_item( item_information.get("trakt_show_id", item_information['trakt_id']), "tvshow", section) g.container_refresh() g.notification( g.ADDON_NAME, g.get_language_string(30300).format(sections_display[selection]), ) g.trigger_widget_refresh()
def _add_to_list(self, item_information): from resources.lib.modules.metadataHandler import MetadataHandler get = MetadataHandler.get_trakt_info lists = self.trakt_api.get_json("users/me/lists") selection = xbmcgui.Dialog().select( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30296)), [get(i, "name") for i in lists], ) if selection == -1: return selection = lists[selection] self.trakt_api.post_json( "users/me/lists/{}/items".format(selection["trakt_id"]), self._info_to_trakt_object(item_information, True), ) g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30286)), g.get_language_string(30294).format(get(selection, "name")), ) g.trigger_widget_refresh()
def try_refresh_token(self): if not self.token or float(time.time()) < (self.expiry - (15 * 60)): return with GlobalLock(self.__class__.__name__, self._threading_lock, True, self.refresh): url = self.oauth_url + "token" response = self.session.post( url, data={ "grant_type": "http://oauth.net/grant_type/device/1.0", "code": self.refresh, "client_secret": self.client_secret, "client_id": self.client_id, }, ) if not self._is_response_ok(response): response = response.json() g.notification( g.ADDON_NAME, "Failed to refresh RD token, please manually re-auth") g.log("RD Refresh error: {}".format(response["error"])) g.log( "Invalid response from Real Debrid - {}".format(response), "error") return False response = response.json() if "access_token" in response: self.token = response["access_token"] if "refresh_token" in response: self.refresh = response["refresh_token"] g.set_setting(RD_AUTH_KEY, self.token) g.set_setting(RD_REFRESH_KEY, self.refresh) g.set_setting(RD_EXPIRY_KEY, str(time.time() + int(response["expires_in"]))) g.log("Real Debrid Token Refreshed") return True
def check_for_updates(self, skin_name=None, silent=False): """ Performs update check for requested theme/s :param skin_name: Optional name of skin to update :type skin_name: str :param silent: Optional argument to disable user feedback :type silent: bool :return: None :rtype: None """ skins = [] if skin_name is None: skins = self.installed_skins else: try: skins.append( [i for i in self.installed_skins if i["skin_name"] == skin_name][0] ) except IndexError: raise SkinNotFoundException(skin_name) if not silent: self._progress_dialog.create(g.ADDON_NAME, g.get_language_string(30085)) self._progress_dialog.update(-1) skins = [i for i in skins if self._skin_can_update(i)] skins = [i for i in skins if self._check_skin_for_update(i)] if len(skins) == 0: if not silent: self._progress_dialog.close() xbmcgui.Dialog().ok(g.ADDON_NAME, g.get_language_string(30084)) return if not silent: self._progress_dialog.close() while skins and len(skins) > 0: self._progress_dialog.create(g.ADDON_NAME, g.get_language_string(30336)) self._progress_dialog.update(-1) selection = xbmcgui.Dialog().select( g.ADDON_NAME, ["{} - {}".format(i["skin_name"], i["version"]) for i in skins], ) if selection == -1: return skin_info = skins[selection] try: self.install_skin(skin_info["update_directory"], True) skins.remove(skin_info) self._progress_dialog.close() xbmcgui.Dialog().ok(g.ADDON_NAME, g.get_language_string(30078)) except Exception as e: g.log_stacktrace() g.log("Failed to update skin: {}".format(selection)) g.notification(g.ADDON_NAME, g.get_language_string(30080)) raise e xbmcgui.Dialog().ok(g.ADDON_NAME, g.get_language_string(30084)) return else: for skin in skins: try: self.install_skin(skin["update_directory"], True) except Exception as e: g.log("Failed to update theme: {}".format(skin["skin_name"])) raise e g.log("Skin updates completed")
def dispatch(params): url = params.get("url") action = params.get("action") action_args = params.get("action_args") pack_select = params.get("packSelect") source_select = params.get("source_select") == "true" overwrite_cache = params.get("seren_reload") == "true" resume = params.get("resume") force_resume_check = params.get("forceresumecheck") == "true" force_resume_off = params.get("forceresumeoff") == "true" force_resume_on = params.get("forceresumeon") == "true" smart_url_arg = params.get("smartPlay") == "true" mediatype = params.get("mediatype") endpoint = params.get("endpoint") g.log("Seren, Running Path - {}".format(g.REQUEST_PARAMS)) if action is None: from resources.lib.gui import homeMenu homeMenu.Menus().home() if action == "genericEndpoint": if mediatype == "movies": from resources.lib.gui.movieMenus import Menus else: from resources.lib.gui.tvshowMenus import Menus Menus().generic_endpoint(endpoint) elif action == "forceResumeShow": from resources.lib.modules import smartPlay from resources.lib.common import tools smartPlay.SmartPlay( tools.get_item_information(action_args)).resume_show() elif action == "moviesHome": from resources.lib.gui import movieMenus movieMenus.Menus().discover_movies() elif action == "moviesUpdated": from resources.lib.gui import movieMenus movieMenus.Menus().movies_updated() elif action == "moviesRecommended": from resources.lib.gui import movieMenus movieMenus.Menus().movies_recommended() elif action == "moviesSearch": from resources.lib.gui import movieMenus movieMenus.Menus().movies_search(action_args) elif action == "moviesSearchResults": from resources.lib.gui import movieMenus movieMenus.Menus().movies_search_results(action_args) elif action == "moviesSearchHistory": from resources.lib.gui import movieMenus movieMenus.Menus().movies_search_history() elif action == "myMovies": from resources.lib.gui import movieMenus movieMenus.Menus().my_movies() elif action == "moviesMyCollection": from resources.lib.gui import movieMenus movieMenus.Menus().my_movie_collection() elif action == "moviesMyWatchlist": from resources.lib.gui import movieMenus movieMenus.Menus().my_movie_watchlist() elif action == "moviesRelated": from resources.lib.gui import movieMenus movieMenus.Menus().movies_related(action_args) elif action == "colorPicker": g.color_picker() elif action == "authTrakt": from resources.lib.indexers import trakt trakt.TraktAPI().auth() elif action == "revokeTrakt": from resources.lib.indexers import trakt trakt.TraktAPI().revoke_auth() elif action == "getSources" or action == "smartPlay": from resources.lib.modules.smartPlay import SmartPlay from resources.lib.common import tools from resources.lib.modules import helpers item_information = tools.get_item_information(action_args) smart_play = SmartPlay(item_information) background = None resolver_window = None try: # Check to confirm user has a debrid provider authenticated and enabled if not g.premium_check(): xbmcgui.Dialog().ok( g.ADDON_NAME, tools.create_multiline_message( line1=g.get_language_string(30208), line2=g.get_language_string(30209), ), ) return None # workaround for widgets not generating a playlist on playback request play_list = smart_play.playlist_present_check(smart_url_arg) if play_list: g.log("Cancelling non playlist playback", "warning") xbmc.Player().play(g.PLAYLIST) return resume_time = smart_play.handle_resume_prompt( resume, force_resume_off, force_resume_on, force_resume_check) background = helpers.show_persistent_window_if_required( item_information) sources = helpers.SourcesHelper().get_sources( action_args, overwrite_cache=overwrite_cache) if sources is None: return if item_information["info"]["mediatype"] == "episode": source_select_style = "Episodes" else: source_select_style = "Movie" if (g.get_int_setting( "general.playstyle{}".format(source_select_style)) == 1 or source_select): if background: background.set_text(g.get_language_string(30198)) from resources.lib.modules import sourceSelect stream_link = sourceSelect.source_select( sources[0], sources[1], item_information) else: if background: background.set_text(g.get_language_string(30032)) stream_link = helpers.Resolverhelper( ).resolve_silent_or_visible(sources[1], sources[2], pack_select) if stream_link is None: g.close_busy_dialog() g.notification(g.ADDON_NAME, g.get_language_string(30033), time=5000) g.show_busy_dialog() if background: background.close() del background if not stream_link: raise NoPlayableSourcesException from resources.lib.modules import player player.SerenPlayer().play_source(stream_link, item_information, resume_time=resume_time) except NoPlayableSourcesException: try: background.close() del background except (UnboundLocalError, AttributeError): pass try: resolver_window.close() del resolver_window except (UnboundLocalError, AttributeError): pass g.cancel_playback() elif action == "preScrape": from resources.lib.database.skinManager import SkinManager from resources.lib.modules import helpers try: from resources.lib.common import tools item_information = tools.get_item_information(action_args) if item_information["info"]["mediatype"] == "episode": source_select_style = "Episodes" else: source_select_style = "Movie" sources = helpers.SourcesHelper().get_sources(action_args) if (g.get_int_setting( "general.playstyle{}".format(source_select_style)) == 0 and sources): from resources.lib.modules import resolver helpers.Resolverhelper().resolve_silent_or_visible( sources[1], sources[2], pack_select) finally: g.set_setting("general.tempSilent", "false") g.log("Pre-scraping completed") elif action == "authRealDebrid": from resources.lib.debrid import real_debrid real_debrid.RealDebrid().auth() elif action == "showsHome": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().discover_shows() elif action == "myShows": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_shows() elif action == "showsMyCollection": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_shows_collection() elif action == "showsMyWatchlist": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_shows_watchlist() elif action == "showsMyProgress": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_show_progress() elif action == "showsMyRecentEpisodes": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_recent_episodes() elif action == "showsRecommended": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_recommended() elif action == "showsUpdated": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_updated() elif action == "showsSearch": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_search(action_args) elif action == "showsSearchResults": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_search_results(action_args) elif action == "showsSearchHistory": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_search_history() elif action == "showSeasons": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().show_seasons(action_args) elif action == "seasonEpisodes": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().season_episodes(action_args) elif action == "showsRelated": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_related(action_args) elif action == "showYears": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_years(action_args) elif action == "searchMenu": from resources.lib.gui import homeMenu homeMenu.Menus().search_menu() elif action == "toolsMenu": from resources.lib.gui import homeMenu homeMenu.Menus().tools_menu() elif action == "clearCache": from resources.lib.common import tools g.clear_cache() elif action == "traktManager": from resources.lib.indexers import trakt from resources.lib.common import tools trakt.TraktManager(tools.get_item_information(action_args)) elif action == "onDeckShows": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().on_deck_shows() elif action == "onDeckMovies": from resources.lib.gui.movieMenus import Menus Menus().on_deck_movies() elif action == "cacheAssist": from resources.lib.modules.cacheAssist import CacheAssistHelper CacheAssistHelper().auto_cache(action_args) elif action == "tvGenres": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_genres() elif action == "showGenresGet": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_genre_list(action_args) elif action == "movieGenres": from resources.lib.gui import movieMenus movieMenus.Menus().movies_genres() elif action == "movieGenresGet": from resources.lib.gui import movieMenus movieMenus.Menus().movies_genre_list(action_args) elif action == "shufflePlay": from resources.lib.modules import smartPlay smartPlay.SmartPlay(action_args).shuffle_play() elif action == "resetSilent": g.set_setting("general.tempSilent", "false") g.notification( "{}: {}".format(g.ADDON_NAME, g.get_language_string(30329)), g.get_language_string(30034), time=5000, ) elif action == "clearTorrentCache": from resources.lib.database.torrentCache import TorrentCache TorrentCache().clear_all() elif action == "openSettings": xbmc.executebuiltin("Addon.OpenSettings({})".format(g.ADDON_ID)) elif action == "myTraktLists": from resources.lib.modules.listsHelper import ListsHelper ListsHelper().my_trakt_lists(mediatype) elif action == "myLikedLists": from resources.lib.modules.listsHelper import ListsHelper ListsHelper().my_liked_lists(mediatype) elif action == "TrendingLists": from resources.lib.modules.listsHelper import ListsHelper ListsHelper().trending_lists(mediatype) elif action == "PopularLists": from resources.lib.modules.listsHelper import ListsHelper ListsHelper().popular_lists(mediatype) elif action == "traktList": from resources.lib.modules.listsHelper import ListsHelper ListsHelper().get_list_items() elif action == "nonActiveAssistClear": from resources.lib.gui import debridServices debridServices.Menus().assist_non_active_clear() elif action == "debridServices": from resources.lib.gui import debridServices debridServices.Menus().home() elif action == "cacheAssistStatus": from resources.lib.gui import debridServices debridServices.Menus().get_assist_torrents() elif action == "premiumize_transfers": from resources.lib.gui import debridServices debridServices.Menus().list_premiumize_transfers() elif action == "showsNextUp": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_next_up() elif action == "runMaintenance": from resources.lib.common import maintenance maintenance.run_maintenance() elif action == "providerTools": from resources.lib.gui import homeMenu homeMenu.Menus().provider_menu() elif action == "installProviders": from resources.lib.modules.providers.install_manager import ( ProviderInstallManager, ) ProviderInstallManager().install_package(action_args) elif action == "uninstallProviders": from resources.lib.modules.providers.install_manager import ( ProviderInstallManager, ) ProviderInstallManager().uninstall_package() elif action == "showsNew": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_new() elif action == "realdebridTransfers": from resources.lib.gui import debridServices debridServices.Menus().list_rd_transfers() elif action == "cleanInstall": from resources.lib.common import maintenance maintenance.wipe_install() elif action == "premiumizeCleanup": from resources.lib.common import maintenance maintenance.premiumize_transfer_cleanup() elif action == "manualProviderUpdate": from resources.lib.modules.providers.install_manager import ( ProviderInstallManager, ) ProviderInstallManager().manual_update() elif action == "clearSearchHistory": from resources.lib.database.searchHistory import SearchHistory SearchHistory().clear_search_history(mediatype) elif action == "externalProviderInstall": from resources.lib.modules.providers.install_manager import ( ProviderInstallManager, ) confirmation = xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30182)) if confirmation == 0: return ProviderInstallManager().install_package(1, url=url) elif action == "externalProviderUninstall": from resources.lib.modules.providers.install_manager import ( ProviderInstallManager, ) confirmation = xbmcgui.Dialog().yesno( g.ADDON_NAME, g.get_language_string(30184).format(url)) if confirmation == 0: return ProviderInstallManager().uninstall_package(package=url, silent=False) elif action == "showsNetworks": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_networks() elif action == "showsNetworkShows": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_networks_results(action_args) elif action == "movieYears": from resources.lib.gui import movieMenus movieMenus.Menus().movies_years() elif action == "movieYearsMovies": from resources.lib.gui import movieMenus movieMenus.Menus().movie_years_results(action_args) elif action == "syncTraktActivities": from resources.lib.database.trakt_sync.activities import TraktSyncDatabase TraktSyncDatabase().sync_activities() elif action == "traktSyncTools": from resources.lib.gui import homeMenu homeMenu.Menus().trakt_sync_tools() elif action == "flushTraktActivities": from resources.lib.database import trakt_sync trakt_sync.TraktSyncDatabase().flush_activities() elif action == "flushTraktDBMeta": from resources.lib.database import trakt_sync trakt_sync.TraktSyncDatabase().clear_all_meta() elif action == "myFiles": from resources.lib.gui import myFiles myFiles.Menus().home() elif action == "myFilesFolder": from resources.lib.gui import myFiles myFiles.Menus().my_files_folder(action_args) elif action == "myFilesPlay": from resources.lib.gui import myFiles myFiles.Menus().my_files_play(action_args) elif action == "forceTraktSync": from resources.lib.database.trakt_sync.activities import TraktSyncDatabase trakt_db = TraktSyncDatabase() trakt_db.flush_activities() trakt_db.sync_activities() elif action == "rebuildTraktDatabase": from resources.lib.database.trakt_sync import TraktSyncDatabase TraktSyncDatabase().re_build_database() elif action == "myUpcomingEpisodes": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_upcoming_episodes() elif action == "myWatchedEpisodes": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().my_watched_episode() elif action == "myWatchedMovies": from resources.lib.gui import movieMenus movieMenus.Menus().my_watched_movies() elif action == "showsByActor": from resources.lib.gui import tvshowMenus tvshowMenus.Menus().shows_by_actor(action_args) elif action == "movieByActor": from resources.lib.gui import movieMenus movieMenus.Menus().movies_by_actor(action_args) elif action == "playFromRandomPoint": from resources.lib.modules import smartPlay smartPlay.SmartPlay(action_args).play_from_random_point() elif action == "refreshProviders": from resources.lib.modules.providers import CustomProviders providers = CustomProviders() providers.update_known_providers() providers.poll_database() elif action == "installSkin": from resources.lib.database.skinManager import SkinManager SkinManager().install_skin() elif action == "uninstallSkin": from resources.lib.database.skinManager import SkinManager SkinManager().uninstall_skin() elif action == "switchSkin": from resources.lib.database.skinManager import SkinManager SkinManager().switch_skin() elif action == "manageProviders": g.show_busy_dialog() from resources.lib.gui.windows.provider_packages import ProviderPackages from resources.lib.database.skinManager import SkinManager window = ProviderPackages( *SkinManager().confirm_skin_path("provider_packages.xml")) window.doModal() del window elif action == "flatEpisodes": from resources.lib.gui.tvshowMenus import Menus Menus().flat_episode_list(action_args) elif action == "runPlayerDialogs": from resources.lib.modules.player import PlayerDialogs PlayerDialogs().display_dialog() elif action == "authAllDebrid": from resources.lib.debrid.all_debrid import AllDebrid AllDebrid().auth() elif action == "checkSkinUpdates": from resources.lib.database.skinManager import SkinManager SkinManager().check_for_updates() elif action == "authPremiumize": from resources.lib.debrid.premiumize import Premiumize Premiumize().auth() elif action == "testWindows": from resources.lib.gui.homeMenu import Menus Menus().test_windows() elif action == "testPlayingNext": from resources.lib.gui import mock_windows mock_windows.mock_playing_next() elif action == "testStillWatching": from resources.lib.gui import mock_windows mock_windows.mock_still_watching() elif action == "testResolverWindow": from resources.lib.gui import mock_windows mock_windows.mock_resolver() elif action == "testSourceSelectWindow": from resources.lib.gui import mock_windows mock_windows.mock_source_select() elif action == "testManualCacheWindow": from resources.lib.gui import mock_windows mock_windows.mock_cache_assist() elif action == "showsPopularRecent": from resources.lib.gui.tvshowMenus import Menus Menus().shows_popular_recent() elif action == "showsTrendingRecent": from resources.lib.gui.tvshowMenus import Menus Menus().shows_trending_recent() elif action == "moviePopularRecent": from resources.lib.gui.movieMenus import Menus Menus().movie_popular_recent() elif action == "movieTrendingRecent": from resources.lib.gui.movieMenus import Menus Menus().movie_trending_recent() elif action == "setDownloadLocation": from resources.lib.modules.download_manager import set_download_location set_download_location() elif action == "downloadManagerView": from resources.lib.gui.windows.download_manager import DownloadManager from resources.lib.database.skinManager import SkinManager window = DownloadManager( *SkinManager().confirm_skin_path("download_manager.xml")) window.doModal() del window elif action == "longLifeServiceManager": from resources.lib.modules.providers.service_manager import ( ProvidersServiceManager, ) ProvidersServiceManager().run_long_life_manager() elif action == "showsRecentlyWatched": from resources.lib.gui.tvshowMenus import Menus Menus().shows_recently_watched() elif action == "toggleLanguageInvoker": from resources.lib.common.maintenance import toggle_reuselanguageinvoker toggle_reuselanguageinvoker()