def get_list_items(self): arguments = g.REQUEST_PARAMS['action_args'] media_type = g.REQUEST_PARAMS.get('media_type', arguments.get('type')) ignore_cache = True if g.REQUEST_PARAMS.get('from_widget') and g.REQUEST_PARAMS.get( 'from_widget').lower() == "true": widget_loaded_setting = "widget_loaded.{}.{}".format( media_type, arguments) if not g.get_bool_runtime_setting(widget_loaded_setting): ignore_cache = False g.set_runtime_setting(widget_loaded_setting, True) list_items = self.lists_database.get_list_content( arguments['username'], arguments['trakt_id'], self._backwards_compatibility(media_type), ignore_cache=ignore_cache, page=g.PAGE, no_paging=self.no_paging) if not list_items: g.log( 'Failed to pull list {} from Trakt/Database'.format( arguments['trakt_id']), 'error') g.cancel_directory() return if media_type in ['tvshow', 'shows']: self.builder.show_list_builder(list_items, no_paging=self.no_paging) elif media_type in ['movie', 'movies']: self.builder.movie_menu_builder(list_items, no_paging=self.no_paging)
def remove_from_index(self, url_hash): """ Removes requested task id from the global index :param url_hash: :return: """ self.download_ids.remove(url_hash) g.set_runtime_setting("SDMIndex", ",".join(self.download_ids))
def update_task_info(self, url_hash, download_dict): """ Updates download information stored in window property for download task :param url_hash: String :param download_dict: dict :return: """ g.set_runtime_setting("sdm.{}".format(url_hash), tools.construct_action_args(download_dict))
def do_cleanup(self): if self._exit or g.abort_requested(): return if g.get_bool_runtime_setting(self._create_key("db.clean.busy")): return g.set_runtime_setting(self._create_key("db.clean.busy"), True) query = "DELETE FROM {} where expires < ?".format(self.cache_table_name) self.execute_sql(query, (self._get_timestamp(),)) g.clear_runtime_setting(self._create_key("db.clean.busy"))
def do_cleanup(self): busy_key = "torrentcache.db.clean.busy" if g.get_bool_runtime_setting(busy_key): return g.set_runtime_setting(busy_key, True) self.execute_sql([ "DELETE FROM {} where expires < ?".format(MOVIE_CACHE_TYPE), "DELETE FROM {} where expires < ?".format(TV_CACHE_TYPE) ], (time.time(), )) g.clear_runtime_setting(busy_key)
def do_cleanup(self): if self._exit or g.abort_requested(): return if g.get_bool_runtime_setting(self._create_key("clean.busy")): return g.set_runtime_setting(self._create_key("clean.busy"), True) self._db_cache.do_cleanup() self._mem_cache.do_cleanup() g.set_runtime_setting(self._create_key("clean.lastexecuted"), CacheBase._get_timestamp()) g.clear_runtime_setting(self._create_key("clean.busy"))
def set(self, cache_id, data, checksum=None, expiration=None): if expiration is None: expiration = datetime.timedelta(hours=24) expires = self._get_timestamp(expiration) cached = (expires, data, checksum) g.set_runtime_setting( cache_id, base64.standard_b64encode(pickle.dumps(cached)).decode(), ) self._get_index() self._index.add((cache_id, expires)) self._save_index()
def do_cleanup(self): if self._exit or g.abort_requested(): return cur_time = datetime.datetime.utcnow() if g.get_runtime_setting(self._create_key("cache.db.clean.busy")): return g.set_runtime_setting(self._create_key("cache.db.clean.busy"), "busy") query = "DELETE FROM {} where expires < ?".format( self.cache_table_name) self.execute_sql(query, (self._get_timestamp(), )) g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), repr(cur_time)) g.clear_runtime_setting(self._create_key("cache.mem.clean.busy"))
def check_cleanup(self): """ Check if a cleanup should be run according to auto_clean_interval and process if required :return: :rtype: """ cur_time = datetime.datetime.utcnow() lastexecuted = g.get_runtime_setting( self._create_key("clean.lastexecuted")) if not lastexecuted: g.set_runtime_setting(self._create_key("clean.lastexecuted"), repr(cur_time)) elif self._cleanup_required_check(lastexecuted, cur_time): self.do_cleanup()
def do_cleanup(self): if self._exit or g.abort_requested(): return cur_timestamp = self._get_timestamp() if g.get_bool_runtime_setting(self._create_key("mem.clean.busy")): return g.set_runtime_setting(self._create_key("mem.clean.busy"), True) self._get_index() for cache_id, expires in self._index: if expires < cur_timestamp: g.clear_runtime_setting(cache_id) g.clear_runtime_setting(self._create_key("mem.clean.busy"))
def set(self, cache_id, data, checksum=None, expiration=datetime.timedelta(hours=24)): expires = self._get_timestamp(expiration) cached = (expires, data, checksum) g.set_runtime_setting( cache_id, codecs.encode(pickle.dumps(cached), "base64").decode(), ) self._get_index() self._index.add((cache_id, expires)) self._save_index()
def _mark_watched_dialog(self): if g.get_runtime_setting("marked_watched_dialog_open"): return if (self.getPlayingFile() and self._running_path and self._running_path != self.getPlayingFile() and self.watched_percentage < self.playCountMinimumPercent and (time.time() - self.playback_timestamp) > 600): xbmc.sleep(10000) g.set_runtime_setting("marked_watched_dialog_open", True) if xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30526)): self._force_marked_watched = True g.set_runtime_setting("marked_watched_dialog_open", False)
def do_cleanup(self): if self._exit or g.abort_requested(): return if g.get_runtime_setting(self._create_key("clean.busy")): return g.set_runtime_setting(self._create_key("clean.busy"), "busy") cur_time = datetime.datetime.utcnow() self._db_cache.do_cleanup() self._mem_cache.do_cleanup() g.set_runtime_setting(self._create_key("clean.lastexecuted"), repr(cur_time)) g.clear_runtime_setting(self._create_key("clean.busy"))
def update_provider_packages(): """ Perform checks for provider package updates :return: None :rtype: None """ provider_check_stamp = g.get_float_runtime_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(30268)) g.set_runtime_setting("provider.updateCheckTimeStamp", g.UNICODE(time.time()))
def onSettingsChanged(self): callback_time = int(time.time()) if g.get_int_runtime_setting( "onSettingsChangedLastCalled") == callback_time: g.log("Debouncing onSettingsChange call", "debug") # This check is to debounce multiple onSettingsChange calls to the nearest second as the callbacks # can come a bit late after setting multiple settings programmatically and cause # the settings persisted flag to be cleared return g.set_runtime_setting("onSettingsChangedLastCalled", callback_time) g.log("SETTINGS UPDATED", "info") if g.SETTINGS_CACHE.get_settings_persisted_flag(): return g.log("FLUSHING SETTINGS CACHE", "info") g.SETTINGS_CACHE.clear_cache() g.trigger_widget_refresh(if_playing=False)
def do_cleanup(self): if self._exit or g.abort_requested(): return cur_time = datetime.datetime.utcnow() cur_timestamp = self._get_timestamp() if g.get_runtime_setting(self._create_key("cache.mem.clean.busy")): return g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), "busy") self._get_index() for cache_id, expires in self._index: if expires < cur_timestamp: g.clear_runtime_setting(cache_id) g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), repr(cur_time)) g.clear_runtime_setting(self._create_key("cache.mem.clean.busy"))
def pre_scrape(): """ Checks whether a item exists in the current playlist after current item and then pre-fetches results :return: :rtype: """ next_position = g.PLAYLIST.getposition() + 1 if next_position >= g.PLAYLIST.size(): return url = g.PLAYLIST[ # pylint: disable=unsubscriptable-object next_position].getPath() if not url: return url = url.replace("getSources", "preScrape") g.set_runtime_setting("tempSilent", True) g.log("Running Pre-Scrape: {}".format(url)) xbmc.executebuiltin('RunPlugin("{}")'.format(url))
def resolve_silent_or_visible(self, sources, item_information, pack_select=False, from_source_select=False, overwrite_cache=False): """ Method to handle automatic background or foreground resolving :param sources: list of sources to handle :param item_information: information on item to play :param pack_select: True if you want to perform a manual file selection :param from_source_select: True if we were called from SS screen :param overwrite_cache: Set to true if you wish to overwrite the current cached return value :return: None if unsuccessful otherwise a playable object """ stream_link = "" release_title = "" if g.get_bool_runtime_setting('tempSilent'): stream_link, release_title = Resolver( ).resolve_multiple_until_valid_link(sources, item_information, pack_select, True) else: try: window = ResolverWindow( *SkinManager().confirm_skin_path('resolver.xml'), item_information=item_information) stream_link, release_title = window.doModal( sources, pack_select, from_source_select=from_source_select, ) finally: del window if item_information['info'][ 'mediatype'] == g.MEDIA_EPISODE and release_title: g.set_runtime_setting( "last_resolved_release_title.{}".format( item_information['info']['trakt_show_id']), release_title) return stream_link
def _save_index(self): cached_string = list(self._index) g.set_runtime_setting(self._index_key, cached_string)
def _run_id(self, i): g.set_runtime_setting(self._create_key(i), True) return i
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": 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 seren_player = player.SerenPlayer() seren_player.play_source(stream_link, item_information, resume_time=resume_time) del seren_player 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_runtime_setting("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_runtime_setting("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 == "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 player_dialogs = PlayerDialogs() player_dialogs.display_dialog() del player_dialogs 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() elif action == "chooseTimeZone": from resources.lib.modules.manual_timezone import choose_timezone choose_timezone()
def _insert_into_index(self): """ Inserts new ID into window index :return: """ g.set_runtime_setting("SDMIndex", ",".join(self.download_ids))
def check_for_addon_update(): """ Perform checks for addon updates and notify user of any available updates :return: None :rtype: None """ if not g.get_bool_setting("general.checkAddonUpdates"): return if "-" in g.VERSION: g.set_runtime_setting("addon.updateCheckTimeStamp", g.UNICODE(time.time())) return update_timestamp = g.get_float_runtime_setting( "addon.updateCheckTimeStamp") if time.time() > (update_timestamp + (24 * (60 * 60))): repo_xml = requests.get( "https://github.com/nixgates/nixgates/raw/master/repo/zips/addons.xml" ) if not repo_xml.status_code == 200: g.log( "Could not connect to repo XML, status: {}".format( repo_xml.status_code), "error", ) return try: xml = tools.ElementTree.fromstring(repo_xml.text) for dir_tag in xml.iterfind( "./addon[@id='repository.nixgates']/extension/dir"): minversion = dir_tag.get('minversion') maxversion = dir_tag.get('maxversion') if ((minversion is None and maxversion is None) or (minversion and maxversion and tools.compare_version_numbers( minversion, g.KODI_FULL_VERSION, include_same=True) and tools.compare_version_numbers( g.KODI_FULL_VERSION, maxversion, include_same=True)) or (maxversion is None and minversion and tools.compare_version_numbers( minversion, g.KODI_FULL_VERSION, include_same=True)) or (minversion is None and maxversion and tools.compare_version_numbers( g.KODI_FULL_VERSION, maxversion, include_same=True))): repo_version = _get_latest_repo_version( dir_tag.find('info').text) if tools.compare_version_numbers(g.CLEAN_VERSION, repo_version): xbmcgui.Dialog().ok( g.ADDON_NAME, g.get_language_string(30199).format(repo_version)) except tools.ElementTree.ParseError as pe: g.log("Could not parse repo XML", "error") finally: g.set_runtime_setting("addon.updateCheckTimeStamp", g.UNICODE(time.time()))
def __exit__(self, exc_type, exc_val, exc_tb): if self._run_once: g.set_runtime_setting(self._create_key("RunOnce"), True) g.set_runtime_setting(self._create_key("CheckSum"), self._check_sum) g.clear_runtime_setting(self._create_key("Running"))
def _run(self): while not g.abort_requested() and self._running(): if g.wait_for_abort(.100): break g.set_runtime_setting(self._create_key("Running"), True) self._check_ran_once_already()