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()
