def install_zip(self, zip_file, silent=False):
file_list = zip_file.namelist()
for i in file_list:
if i.startswith('/') or '..' in i:
raise Exception
meta_file = None
for i in file_list:
if i.startswith('meta.json'):
meta_file = i
if meta_file is not None:
meta = zip_file.open(meta_file)
meta = meta.readlines()
meta = ''.join(meta)
meta = meta.replace(' ', '').replace('\r', '').replace('\n', '')
meta = json.loads(meta)
requirements = ['author', 'name', 'version']
for i in requirements:
if i not in meta:
if not silent:
self.failed_prompt()
tools.log(
'Source pack is malformed, please check and correct issue in the meta file'
)
return
author = meta['author']
version = meta['version']
pack_name = meta['name']
remote_meta = meta.get('remote_meta', '')
else:
if not silent:
self.failed_prompt()
tools.log(
'Source pack is malformed, please check and correct issue in the meta file'
)
import traceback
traceback.print_exc()
raise Exception
if remote_meta == '':
tools.showDialog.ok(tools.addonName,
tools.lang(33016).encode('utf-8'))
line1 = tools.colorString(tools.lang(33001).encode(
'utf-8')) + " %s - v%s" % (pack_name, version)
line2 = tools.colorString(
tools.lang(33002).encode('utf-8')) + "%s" % author
line3 = tools.lang(33003).encode('utf-8')
if not silent:
accept = tools.showDialog.yesno(
tools.addonName + " - %s" % tools.lang(33004).encode('utf-8'),
line1, line2, line3,
tools.lang(33005).encode('utf-8'),
tools.lang(33006).encode('utf-8'))
if accept == 0:
return
self.pre_update_collection = [
i for i in database.get_providers() if i['package'] == pack_name
]
database.remove_package_providers(pack_name)
folders = ['providerModules/', 'providers/']
meta_output_location = os.path.join(tools.dataPath, 'providerMeta',
'%s.json' % pack_name)
if os.path.isfile(meta_output_location):
try:
os.rename(meta_output_location,
'%s.temp' % meta_output_location)
except Exception as e:
self.failure_cleanup(meta_output_location, pack_name, folders)
tools.log('Failed to create temporary meta file')
if not silent:
tools.showDialog.ok(tools.addonName,
tools.lang(33007).encode('utf-8'))
return
try:
self.output_meta(meta)
except:
self.failure_cleanup(meta_output_location, pack_name, folders)
tools.log('Failed to create new meta file')
if not silent:
self.failed_prompt()
return
else:
self.output_meta(meta)
if not silent:
install_progress = tools.progressDialog
install_progress.create(
tools.addonName,
'%s - %s' % (pack_name, tools.lang(33008).encode('utf-8')),
tools.lang(33009).encode('utf-8'))
install_progress.update(-1)
try:
for folder in folders:
try:
folder_path = os.path.join(tools.dataPath,
folder.strip('/'), pack_name)
if os.path.exists(folder_path):
os.rename(folder_path, '%s.temp' % folder_path)
for file in file_list:
if file.startswith(folder):
zip_file.extract(file, tools.dataPath)
except:
tools.log('Failed to extract to folder - %s' % folder)
import traceback
traceback.print_exc()
self.failure_cleanup(meta_output_location, pack_name,
folders)
if not silent:
self.failed_prompt()
return
try:
zip_file.close()
except:
pass
if not silent:
try:
install_progress.close()
except:
pass
if not silent:
tools.showDialog.ok(
tools.addonName,
'%s - %s' % (tools.lang(33010).encode('utf-8'), pack_name))
except:
import traceback
traceback.print_exc()
if not silent:
try:
install_progress.close()
tools.showDialog.ok(
tools.addonName, '%s - %s' %
(tools.lang(33012).encode('utf-8'), pack_name),
tools.lang(33011).encode('utf-8'))
except:
pass
return
if os.path.exists('%s.temp' % meta_output_location):
os.remove('%s.temp' % meta_output_location)
for folder in folders:
folder_path = os.path.join(tools.dataPath, folder.strip('/'),
pack_name)
if os.path.exists('%s.temp' % folder_path):
shutil.rmtree('%s.temp' % folder_path)
tools.log('Refreshing provider database ')
database.add_provider_package(pack_name, author, remote_meta, version)
self.update_known_providers()
return True
def check_for_updates(self, skin_name=None, silent=False):
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:
tools.progressDialog.create(tools.addonName, tools.lang(33019))
tools.progressDialog.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:
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName, tools.lang(33018))
return
if not silent:
tools.progressDialog.close()
while skins and len(skins) > 0:
tools.progressDialog.create(tools.addonName, tools.lang(40311))
tools.progressDialog.update(-1)
selection = tools.showDialog.select(tools.addonName, [
'{} - {}'.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)
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName, tools.lang(40318))
except:
import traceback
traceback.print_exc()
tools.log('Failed to update skin: {}'.format(
selection['skin_name']))
tools.showDialog.notification(tools.addonName,
tools.lang(33013))
tools.showDialog.ok(tools.addonName, tools.lang(33018))
return
for skin in skins:
try:
self.install_skin(skin['update_directory'], True)
except:
tools.log('Failed to update theme: {}'.format(
skin['skin_name']))
tools.log('Skin updates completed')
def premiumize_downloader(self, torrent_object):
current_percent = 0
debrid = premiumize.PremiumizeFunctions()
try:
transfer_id = debrid.create_transfer(
torrent_object['magnet'])['id']
tools.showDialog.notification(tools.addonName,
tools.lang(32072).encode('utf-8'))
database.add_assist_torrent(transfer_id, 'premiumize', 'queued',
torrent_object['release_title'],
str(current_percent))
except:
tools.log('Failed to start premiumize debrid transfer', 'error')
return
timestamp = time.time()
while not monitor.abortRequested():
try:
if monitor.waitForAbort(120):
break
transfer_status = [
i for i in debrid.list_transfers()['transfers']
if i['id'] == transfer_id
][0]
current_percent = transfer_status['progress']
if transfer_status['status'] == 'finished':
database.add_assist_torrent(
transfer_id, 'premiumize', transfer_status['status'],
torrent_object['release_title'], str(current_percent))
if self.notified == False:
tools.showDialog.notification(
tools.addonName + ': %s' % self.title,
'New cached sources have been created for %s' %
self.title,
time=5000)
debrid.delete_transfer(transfer_id)
database.add_premiumize_transfer(transfer_id)
from resources.lib.common import maintenance
maintenance.premiumize_transfer_cleanup()
break
if current_percent == transfer_status['progress']:
if timestamp == (time.time() + 10800):
database.add_assist_torrent(
transfer_id, 'premiumize', 'failed',
torrent_object['release_title'],
str(current_percent))
debrid.delete_transfer(transfer_id)
tools.showDialog.notification(
tools.addonName,
'Cache assist for %s has failed due to no progress'
% self.title)
break
continue
else:
database.add_assist_torrent(
transfer_id, 'premiumize', transfer_status['status'],
torrent_object['release_title'], str(current_percent))
except:
database.add_assist_torrent(transfer_id, 'premiumize',
'failed',
torrent_object['release_title'],
str(current_percent))
debrid.delete_transfer(transfer_id)
break
return
def resolve(self, sources, args, pack_select=False):
try:
if 'showInfo' in args:
background = args['showInfo']['art']['fanart']
else:
background = args['fanart']
self.setText(tools.lang(33000).encode('utf-8'))
self.setBackground(background)
stream_link = None
loop_count = 0
# Begin resolving links
tools.log('Attempting to Resolve file link', 'info')
for i in sources:
debrid_provider = i.get('debrid_provider', '')
loop_count += 1
try:
if self.is_canceled():
self.close()
return
if 'size' in i:
i['info'].append(tools.source_size_display(i['size']))
loop_count_string = "(" + str(loop_count) + " of " + str(
len(sources)) + ")"
line1 = "%s %s - %s" % (tools.lang(32036).encode('utf-8'),
tools.colorString(
i['release_title']),
loop_count_string)
line2 = "%s %s | Source: %s" % (
tools.lang(32037).encode('utf-8'),
tools.colorString(debrid_provider.upper()),
tools.colorString(i['source']))
line3 = '%s %s | Info: %s' % (
tools.lang(32038).encode('utf-8'),
tools.colorString(i['quality']),
tools.colorString(" ".join(i['info'])))
self.setText(line1)
self.setText2(line2)
self.setText3(line3)
if i['type'] == 'torrent':
if i['debrid_provider'] == 'premiumize':
stream_link = self.premiumizeResolve(
i, args, pack_select)
elif i['debrid_provider'] == 'real_debrid':
stream_link = self.realdebridResolve(i, args)
if stream_link is None:
tools.log('Failed to resolve for torrent %s' %
i['release_title'])
continue
else:
self.return_data = stream_link
self.close()
return
elif i['type'] == 'hoster':
# Quick fallback to speed up resolving while direct and free hosters are not supported
if 'debrid_provider' not in i:
continue
provider = i['provider_imports']
providerModule = __import__('%s.%s' %
(provider[0], provider[1]),
fromlist=[''])
providerModule = providerModule.source()
try:
i['url'] = providerModule.resolve(i['url'])
except:
import traceback
traceback.print_exc()
pass
if i['url'] is None:
continue
if 'debrid_provider' in i:
if i['debrid_provider'] == 'premiumize' and tools.getSetting(
'premiumize.enabled') == 'true':
stream_link = self.premiumizeResolve(i, args)
if stream_link is None:
continue
if i['debrid_provider'] == 'real_debrid':
stream_link = self.realdebridResolve(i, args)
if stream_link is None:
continue
else:
# Currently not supporting free hosters at this point in time
# ResolveURL and Direct link testing needs to be tested first
continue
try:
try:
headers = i['url'].rsplit('|', 1)[1]
except:
headers = ''
headers = tools.quote_plus(headers).replace(
'%3D', '=') if ' ' in headers else headers
headers = dict(tools.parse_qsl(headers))
live_check = requests.head(i['url'],
headers=headers)
if not live_check.status_code == 200:
continue
stream_link = i['url']
except:
stream_link = None
if stream_link is None:
continue
else:
self.return_data = stream_link
self.close()
return
continue
except:
import traceback
traceback.print_exc()
continue
self.close()
if tools.getSetting('premiumize.enabled') == 'true':
tools.execute(
'RunPlugin("plugin://plugin.video.%s/?action=premiumizeCleanup")'
% tools.addonName.lower())
return
except:
import traceback
traceback.print_exc()
self.close()
return
def discoverMovies(self):
tools.addDirectoryItem(
tools.lang(32007).encode('utf-8'), 'moviesPopular&page=1', '', '')
if tools.getSetting('trakt.auth') is not '':
tools.addDirectoryItem(
tools.lang(32008).encode('utf-8'), 'moviesRecommended', '', '')
tools.addDirectoryItem(
tools.lang(32009).encode('utf-8'), 'moviesTrending&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32010).encode('utf-8'), 'moviesPlayed&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32011).encode('utf-8'), 'moviesWatched&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32012).encode('utf-8'), 'moviesCollected&page=1', '',
'')
tools.addDirectoryItem(
tools.lang(32013).encode('utf-8'), 'moviesAnticipated&page=1', '',
'')
tools.addDirectoryItem(
tools.lang(32015).encode('utf-8'), 'moviesBoxOffice', '', '')
tools.addDirectoryItem(
tools.lang(32014).encode('utf-8'), 'moviesUpdated&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32062).encode('utf-8'), 'movieGenres&page=1', '', '')
tools.addDirectoryItem(tools.lang(32016), 'moviesSearch', '', '')
tools.closeDirectory('addons', cacheToDisc=True)
def myMovies(self):
tools.addDirectoryItem(tools.lang(32017), 'moviesMyCollection', '', '')
tools.addDirectoryItem(tools.lang(32018), 'moviesMyWatchlist', '', '')
tools.addDirectoryItem('My Movie Lists',
'myTraktLists&actionArgs=movies', '', '')
tools.closeDirectory('addons', cacheToDisc=True)
def searchMenu(self):
tools.addDirectoryItem(
tools.lang(32039).encode('utf-8'), 'moviesSearch', '', '')
tools.addDirectoryItem(
tools.lang(32040).encode('utf-8'), 'showsSearch', '', '')
tools.closeDirectory('addons', cacheToDisc=True)
def removeFromWatchlist(self, trakt_object):
self.post_request('sync/watchlist/remove', postData=trakt_object)
tools.container_refresh()
tools.trigger_widget_refresh()
tools.showDialog.notification('{}: {}'.format(tools.addonName, tools.lang(40280)), tools.lang(40287))
def smart_play_show(self, append_playlist=False):
self.window = windows.smart_play_background()
self.window.setBackground(self.poster)
self.window.setText(tools.lang(32094))
if not append_playlist:
self.window.show()
self.window.setProgress(0)
self.window.setProgress(40)
self.window.setText(tools.lang(32095))
if not append_playlist:
tools.playList.clear()
if 'episodeInfo' not in self.info_dictionary:
if tools.getSetting('trakt.auth') == '':
tools.showDialog.ok(tools.addonName, tools.lang(32093))
return
else:
self.user_history = TraktAPI().json_response(
'sync/history/shows/%s' % self.show_trakt_id)
season, episode = self.get_resume_episode()
if self.final_episode_check(season, episode) is True:
season = 1
episode = 1
else:
season = self.info_dictionary['episodeInfo']['info']['season']
episode = self.info_dictionary['episodeInfo']['info']['episode']
self.window.setText(tools.lang(32096))
self.window.setProgress(60)
if append_playlist:
# Add next seasons episodes to the currently playing playlist and then finish up
playlist = tvshowMenus.Menus().episodeListBuilder(
self.show_trakt_id, season, hide_unaired=True, smartPlay=True)
for i in playlist:
# Confirm that the episode meta we have received from TVDB are for the correct episodes
# If trakt provides the incorrect TVDB ID it's possible to begin play from the incorrect episode
params = dict(tools.parse_qsl(i[0].replace('?', '')))
actionArgs = json.loads(params.get('actionArgs'))
if actionArgs['episodeInfo']['info']['episode'] < episode:
continue
# If the episode is confirmed ok, add it to our playlist.
tools.playList.add(url=i[0], listitem=i[1])
return
season_episodes = tvshowMenus.Menus().episodeListBuilder(
self.show_trakt_id, season, smartPlay=True)
self.window.setText(tools.lang(32097))
self.window.setProgress(80)
playlist = []
for ep in season_episodes:
path_arguments = dict(tools.parse_qsl(ep[0].replace('?', '')))
episode_args = json.loads(
tools.unquote(path_arguments['actionArgs']))
ep_no = int(episode_args['episodeInfo']['info']['episode'])
if ep_no >= episode:
playlist.append(ep)
self.window.setText('Starting Playback')
self.window.setProgress(100)
for i in playlist:
tools.playList.add(url=i[0], listitem=i[1])
tools.log(
'Begining play from Season %s Episode %s' % (season, episode),
'info')
self.window.close()
tools.player().play(tools.playList)
def showsAnticipated(self, page):
traktList = trakt.json_response('shows/anticipated?page=%s&extended=full' % page)
self.showListBuilder(traktList)
tools.addDirectoryItem(tools.lang(32019), 'showsAnticipated&page=%s' % (int(page) + 1), '', '')
tools.closeDirectory('tvshows')
def discoverShows(self):
tools.addDirectoryItem(
tools.lang(32007).encode('utf-8'), 'showsPopular&page=1', '', '')
if tools.getSetting('trakt.auth') is not '':
tools.addDirectoryItem(
tools.lang(32008).encode('utf-8'), 'showsRecommended', '', '')
tools.addDirectoryItem(
tools.lang(32009).encode('utf-8'), 'showsTrending&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32067).encode('utf-8'), 'showsNew', '', '')
tools.addDirectoryItem(
tools.lang(32010).encode('utf-8'), 'showsPlayed&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32011).encode('utf-8'), 'showsWatched&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32012).encode('utf-8'), 'showsCollected&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32013).encode('utf-8'), 'showsAnticipated&page=1', '',
'')
tools.addDirectoryItem(
tools.lang(32014).encode('utf-8'), 'showsUpdated&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32062).encode('utf-8'), 'tvGenres', '', '')
# show genres is now labeled as tvGenres to support genre icons in skins
if tools.getSetting('searchHistory') == 'false':
tools.addDirectoryItem(
tools.lang(32016).encode('utf-8'), 'showsSearch', '', '')
else:
tools.addDirectoryItem(
tools.lang(32016).encode('utf-8'), 'showsSearchHistory', '',
'')
tools.closeDirectory('addons', cacheToDisc=True)
def smart_play_show(self, append_playlist=False):
self.window = windows.smart_play_background()
self.window.setBackground(self.poster)
self.window.setText(tools.lang(32094).encode('utf-8'))
if not append_playlist:
self.window.show()
self.window.setProgress(0)
self.window.setProgress(40)
self.window.setText(tools.lang(32095).encode('utf-8'))
if not append_playlist:
tools.playList.clear()
if 'episodeInfo' not in self.info_dictionary:
if tools.getSetting('trakt.auth') == '':
tools.showDialog.ok(tools.addonName,
tools.lang(32093).encode('utf-8'))
return
season, episode = self.get_resume_episode()
if self.final_episode_check(season, episode) is True:
season = 1
episode = 1
season_object = TraktAPI().json_response(
'shows/%s/seasons?extended=full' %
self.info_dictionary['ids']['trakt'])
season_object = [x for x in season_object if x['number'] == season]
self.info_dictionary = tvshowMenus.Menus().seasonListBuilder(
season_object, self.info_dictionary, smartPlay=True)
self.info_dictionary = json.loads(
tools.unquote(self.info_dictionary))
else:
season = self.info_dictionary['episodeInfo']['info']['season']
episode = self.info_dictionary['episodeInfo']['info']['episode']
self.window.setText(tools.lang(32096).encode('utf-8'))
self.window.setProgress(60)
episode_list = database.get(
TraktAPI().json_response, 12, 'shows/%s/seasons/%s?extended=full' %
(self.show_trakt_id, str(season)))
playlist = []
for i in episode_list:
if i['number'] < episode:
continue
playlist.append(i)
if append_playlist:
tools.log("STARTING PLAYLIST GENERATION")
playlist = tvshowMenus.Menus().episodeListBuilder(
playlist, self.info_dictionary, smartPlay=True)
for i in playlist:
# Confirm that the episode meta we have received from TVDB are for the correct episodes
# If trakt provides the incorrect TVDB ID it's possible to begin play from the incorrect episode
params = dict(tools.parse_qsl(i[0].replace('?', '')))
actionArgs = json.loads(params.get('actionArgs'))
if actionArgs['episodeInfo']['info']['episode'] < episode:
continue
# If the episode is confirmed ok, add it to our playlist.
tools.log("ADDING ITEM TO PLAYLIST")
tools.playList.add(url=i[0], listitem=i[1])
return
self.window.setText(tools.lang(32097).encode('utf-8'))
self.window.setProgress(80)
actionArgs = {}
actionArgs['playlist'] = playlist
actionArgs['info_dictionary'] = self.info_dictionary
actionArgs = tools.quote(json.dumps(actionArgs))
# Begin nasty Kodi 18 Skin workaround
tools.execute(
'RunPlugin(plugin://plugin.video.%s?action=buildPlaylist&actionArgs=%s)'
% (tools.addonName.lower(), actionArgs))
self.window.close()
def api(params):
from resources.lib.common import tools
from resources.lib.modules import database
tools.SETTINGS_CACHE = {}
try:
url = params.get('url')
action = params.get('action')
page = params.get('page')
actionArgs = params.get('actionArgs')
pack_select = params.get('packSelect')
source_select = params.get('source_select')
seren_reload = params.get('seren_reload')
if seren_reload == 'true':
seren_reload = True
except:
print('Welcome to console mode')
print('Command Help:')
print(' - Menu Number: opens the relevant menu page')
print(' - shell: opens a interactive python shell within Seren')
print(' - action xxx: run a custom Seren URL argument')
url = ''
action = None
page = ''
actionArgs = ''
pack_select = ''
source_select = ''
seren_reload = ''
unit_tests = params.get('unit_tests', False)
if unit_tests:
tools.enable_unit_tests()
tools.log('Seren, Running Path - Action: %s, actionArgs: %s' %
(action, actionArgs))
if action == None:
from resources.lib.gui import homeMenu
homeMenu.Menus().home()
if action == 'smartPlay':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).fill_playlist()
if action == 'playbackResume':
from resources.lib.modules import smartPlay
smart = smartPlay.SmartPlay(actionArgs)
smart.workaround()
if action == 'moviesHome':
from resources.lib.gui import movieMenus
movieMenus.Menus().discoverMovies()
if action == 'moviesPopular':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesPopular(page)
if action == 'moviesTrending':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesTrending(page)
if action == 'moviesPlayed':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesPlayed(page)
if action == 'moviesWatched':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesWatched(page)
if action == 'moviesCollected':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesCollected(page)
if action == 'moviesAnticipated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesAnticipated(page)
if action == 'moviesBoxOffice':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesBoxOffice()
if action == 'moviesUpdated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesUpdated(page)
if action == 'moviesRecommended':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesRecommended()
if action == 'moviesSearch':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearch(actionArgs)
if action == 'moviesSearchResults':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearchResults(actionArgs)
if action == 'moviesSearchHistory':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearchHistory()
if action == 'myMovies':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovies()
if action == 'moviesMyCollection':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovieCollection()
if action == 'moviesMyWatchlist':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovieWatchlist()
if action == 'moviesRelated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesRelated(actionArgs)
if action == 'colorPicker':
tools.colorPicker()
if action == 'authTrakt':
from resources.lib.indexers import trakt
trakt.TraktAPI().auth()
if action == 'revokeTrakt':
from resources.lib.indexers import trakt
trakt.TraktAPI().revokeAuth()
if action == 'getSources':
try:
from resources.lib.gui.windows.persistent_background import PersistentBackground
item_information = tools.get_item_information(actionArgs)
# Assume if we couldn't get information using the normal method, that it's the legacy method
if item_information is None:
item_information = actionArgs
if not tools.premium_check():
tools.showDialog.ok(tools.addonName, tools.lang(40146),
tools.lang(40147))
return None
if tools.playList.getposition() == 0 and tools.getSetting(
'general.scrapedisplay') == '0':
display_background = True
else:
display_background = False
if tools.getSetting('general.scrapedisplay') == '1':
tools.closeBusyDialog()
if display_background:
background = PersistentBackground('persistent_background.xml',
tools.addonDir,
actionArgs=actionArgs)
background.setText(tools.lang(32045))
background.show()
from resources.lib.modules import getSources
uncached_sources, source_results, args = database.get(
getSources.getSourcesHelper,
1,
actionArgs,
seren_reload=seren_reload,
seren_sources=True)
if len(source_results) <= 0:
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
return
if 'showInfo' in item_information:
source_select_style = 'Episodes'
else:
source_select_style = 'Movie'
if tools.getSetting(
'general.playstyle%s' %
source_select_style) == '1' or source_select == 'true':
try:
background.setText(tools.lang(40135))
except:
pass
from resources.lib.modules import sourceSelect
stream_link = sourceSelect.sourceSelect(
uncached_sources, source_results, actionArgs)
if stream_link is None:
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
raise Exception
else:
try:
background.setText(tools.lang(32046))
except:
pass
from resources.lib.modules import resolver
resolver_window = resolver.Resolver('resolver.xml',
tools.addonDir,
actionArgs=actionArgs)
stream_link = database.get(resolver_window.doModal,
1,
source_results,
args,
pack_select,
seren_reload=seren_reload)
del resolver_window
if stream_link is None:
tools.closeBusyDialog()
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
raise Exception
try:
background.close()
except:
pass
try:
del background
except:
pass
from resources.lib.modules import player
player.serenPlayer().play_source(stream_link, actionArgs)
except:
# Perform cleanup and make sure all open windows close and playlist is cleared
try:
tools.closeBusyDialog()
except:
pass
try:
background.close()
except:
pass
try:
del background
except:
pass
try:
sources_window.close()
except:
pass
try:
del sources_window
except:
pass
try:
resolver_window.close()
except:
pass
try:
del resolver_window
except:
pass
try:
tools.playList.clear()
except:
pass
try:
tools.closeOkDialog()
except:
pass
try:
tools.cancelPlayback()
except:
pass
if action == 'preScrape':
try:
item_information = tools.get_item_information(actionArgs)
if 'showInfo' in item_information:
source_select_style = 'Episodes'
else:
source_select_style = 'Movie'
from resources.lib.modules import getSources
uncached_sources, source_results, args = database.get(
getSources.getSourcesHelper,
1,
actionArgs,
seren_reload=seren_reload,
seren_sources=True)
if tools.getSetting('general.playstyle%s' %
source_select_style) == '0':
from resources.lib.modules import resolver
from resources.lib.modules import resolver
resolver_window = resolver.Resolver('resolver.xml',
tools.addonDir,
actionArgs=actionArgs)
database.get(resolver_window.doModal,
1,
source_results,
args,
pack_select,
seren_reload=seren_reload)
tools.setSetting(id='general.tempSilent', value='false')
except:
tools.setSetting(id='general.tempSilent', value='false')
import traceback
traceback.print_exc()
pass
tools.log('Pre-scraping completed')
if action == 'authRealDebrid':
from resources.lib.debrid import real_debrid
real_debrid.RealDebrid().auth()
if action == 'showsHome':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().discoverShows()
if action == 'myShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShows()
if action == 'showsMyCollection':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShowCollection()
if action == 'showsMyWatchlist':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShowWatchlist()
if action == 'showsMyProgress':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myProgress()
if action == 'showsMyRecentEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myRecentEpisodes()
if action == 'showsPopular':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsPopular(page)
if action == 'showsRecommended':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsRecommended()
if action == 'showsTrending':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsTrending(page)
if action == 'showsPlayed':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsPlayed(page)
if action == 'showsWatched':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsWatched(page)
if action == 'showsCollected':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsCollected(page)
if action == 'showsAnticipated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsAnticipated(page)
if action == 'showsUpdated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsUpdated(page)
if action == 'showsSearch':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsSearch(actionArgs)
if action == 'showsSearchResults':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsSearchResults(actionArgs)
if action == 'showsSearchHistory':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showSearchHistory()
if action == 'showSeasons':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showSeasons(actionArgs)
if action == 'seasonEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().seasonEpisodes(actionArgs)
if action == 'showsRelated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsRelated(actionArgs)
if action == 'showYears':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showYears(actionArgs, page)
if action == 'searchMenu':
from resources.lib.gui import homeMenu
homeMenu.Menus().searchMenu()
if action == 'toolsMenu':
from resources.lib.gui import homeMenu
homeMenu.Menus().toolsMenu()
if action == 'clearCache':
from resources.lib.common import tools
tools.clearCache()
if action == 'traktManager':
from resources.lib.indexers import trakt
trakt.TraktAPI().traktManager(actionArgs)
if action == 'onDeckShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().onDeckShows()
if action == 'onDeckMovies':
from resources.lib.gui.movieMenus import Menus
Menus().onDeckMovies()
if action == 'cacheAssist':
from resources.lib.modules import cacheAssist
cacheAssist.CacheAssit(actionArgs)
if action == 'tvGenres':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showGenres()
if action == 'showGenresGet':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showGenreList(actionArgs, page)
if action == 'movieGenres':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieGenres()
if action == 'movieGenresGet':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieGenresList(actionArgs, page)
if action == 'filePicker':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).torrent_file_picker()
if action == 'shufflePlay':
from resources.lib.modules import smartPlay
try:
smart = smartPlay.SmartPlay(actionArgs).shufflePlay()
except:
import traceback
traceback.print_exc()
pass
if action == 'resetSilent':
tools.setSetting('general.tempSilent', 'false')
tools.showDialog.notification(tools.addonName + ": Silent scrape",
tools.lang(32048),
time=5000)
if action == 'clearTorrentCache':
from resources.lib.modules import database
database.torrent_cache_clear()
if action == 'openSettings':
tools.execute('Addon.OpenSettings(%s)' % tools.addonInfo('id'))
if action == 'myTraktLists':
from resources.lib.indexers import trakt
trakt.TraktAPI().myTraktLists(actionArgs)
if action == 'traktList':
from resources.lib.indexers import trakt
trakt.TraktAPI().getListItems(actionArgs, page)
if action == 'nonActiveAssistClear':
from resources.lib.gui import debridServices
debridServices.Menus().assist_non_active_clear()
if action == 'debridServices':
from resources.lib.gui import debridServices
debridServices.Menus().home()
if action == 'cacheAssistStatus':
from resources.lib.gui import debridServices
debridServices.Menus().get_assist_torrents()
if action == 'premiumizeTransfers':
from resources.lib.gui import debridServices
debridServices.Menus().list_premiumize_transfers()
if action == 'showsNextUp':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myNextUp()
if action == 'runMaintenance':
from resources.lib.common import maintenance
maintenance.run_maintenance()
if action == 'providerTools':
from resources.lib.gui import homeMenu
homeMenu.Menus().providerMenu()
if action == 'adjustProviders':
from resources.lib.modules import customProviders
customProviders.providers().adjust_providers(actionArgs)
if action == 'adjustPackage':
from resources.lib.modules import customProviders
customProviders.providers().adjust_providers(actionArgs,
package_disable=True)
if action == 'installProviders':
from resources.lib.modules import customProviders
customProviders.providers().install_package(actionArgs)
if action == 'uninstallProviders':
from resources.lib.modules import customProviders
customProviders.providers().uninstall_package()
if action == 'showsNew':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().newShows()
if action == 'realdebridTransfers':
from resources.lib.gui import debridServices
debridServices.Menus().list_RD_transfers()
if action == 'cleanInstall':
from resources.lib.common import maintenance
maintenance.wipe_install()
if action == 'buildPlaylistWorkaround':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).resume_playback()
if action == 'premiumizeCleanup':
from resources.lib.common import maintenance
maintenance.premiumize_transfer_cleanup()
if action == 'test2':
tools.log('Nope')
if action == 'manualProviderUpdate':
from resources.lib.modules import customProviders
customProviders.providers().manual_update()
if action == 'clearSearchHistory':
from resources.lib.modules import database
database.clearSearchHistory()
tools.showDialog.ok(tools.addonName, 'Search History has been cleared')
if action == 'externalProviderInstall':
from resources.lib.modules import customProviders
confirmation = tools.showDialog.yesno(tools.addonName,
tools.lang(40117))
if confirmation == 0:
sys.exit()
customProviders.providers().install_package(1, url=url)
if action == 'externalProviderUninstall':
from resources.lib.modules import customProviders
confirmation = tools.showDialog.yesno(tools.addonName,
tools.lang(40119) % url)
if confirmation == 0:
sys.exit()
customProviders.providers().uninstall_package(package=url,
silent=False)
if action == 'showsNetworks':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsNetworks()
if action == 'showsNetworkShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsNetworkShows(actionArgs, page)
if action == 'movieYears':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieYears()
if action == 'movieYearsMovies':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieYearsMovies(actionArgs, page)
if action == 'syncTraktActivities':
from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
TraktSyncDatabase().sync_activities()
if action == 'traktSyncTools':
from resources.lib.gui import homeMenu
homeMenu.Menus().traktSyncTools()
if action == 'flushTraktActivities':
from resources.lib.modules import trakt_sync
trakt_sync.TraktSyncDatabase().flush_activities()
if action == 'flushTraktDBMeta':
from resources.lib.modules import trakt_sync
trakt_sync.TraktSyncDatabase().clear_all_meta()
if action == 'myFiles':
from resources.lib.gui import myFiles
myFiles.Menus().home()
if action == 'myFilesFolder':
from resources.lib.gui import myFiles
myFiles.Menus().myFilesFolder(actionArgs)
if action == 'myFilesPlay':
from resources.lib.gui import myFiles
myFiles.Menus().myFilesPlay(actionArgs)
if action == 'forceTraktSync':
from resources.lib.modules import trakt_sync
from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
trakt_sync.TraktSyncDatabase().flush_activities()
TraktSyncDatabase().sync_activities()
if action == 'rebuildTraktDatabase':
from resources.lib.modules.trakt_sync import TraktSyncDatabase
TraktSyncDatabase().re_build_database()
if action == 'myUpcomingEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myUpcomingEpisodes()
if action == 'showsByActor':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsByActor(actionArgs)
if action == 'movieByActor':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesByActor(actionArgs)
if action == 'playFromRandomPoint':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).play_from_random_point()
if action == 'refreshProviders':
from resources.lib.modules.customProviders import providers
providers().update_known_providers()
if unit_tests:
items = tools.xbmcplugin.DIRECTORY.items
tools.xbmcplugin.DIRECTORY.items = []
return items
def failed_prompt(self):
tools.showDialog.ok(tools.addonName,
tools.lang(33013).encode('utf-8'),
tools.lang(33011).encode('utf-8'))
def showListBuilder(self, traktList, forceResume=False, info_only=False):
self.threadList = []
try:
if len(traktList) == 0: return
except:
return
if 'show' in traktList[0]:
buildList = [i['show'] for i in traktList]
traktList = buildList
for item in traktList:
if tools.getSetting('general.metalocation') == '1':
self.threadList.append(
Thread(target=self.tvdbShowListWorker, args=(item, )))
else:
self.threadList.append(
Thread(target=self.tmdbShowListWorker, args=(item, )))
self.runThreads()
self.itemList = tools.sort_list_items(self.itemList, traktList)
if tools.getSetting('trakt.auth') != '':
traktWatched = trakt.json_response(
'sync/watched/shows?extended=full')
for listItem in self.itemList:
try:
for show in traktWatched:
if show['show']['ids']['trakt'] == listItem['ids'][
'trakt']:
listItem['info']['playcount'] = 1
episodes = 0
for season in show['seasons']:
episodes += len(season['episodes'])
if episodes < show['show']['aired_episodes']:
listItem['info']['playcount'] = 0
break
except:
pass
for item in self.itemList:
if item is None: continue
try:
args = {}
cm = []
action = ''
# Add Arguments to pass with items
args['ids'] = item['ids']
args['info'] = item['info']
args['art'] = item['art']
name = item['info']['tvshowtitle']
args = tools.quote(json.dumps(args, sort_keys=True))
if info_only == True:
return args
if 'setCast' in item:
set_cast = item['setCast']
else:
set_cast = None
if tools.getSetting('smartplay.clickresume'
) == 'true' or forceResume is True:
action = 'smartPlay'
else:
action = 'showSeasons'
# Context Menu Items
cm.append(
(tools.lang(32070).encode('utf-8'),
'XBMC.RunPlugin(%s?action=shufflePlay&actionArgs=%s)' %
(sysaddon, args)))
cm.append(
(tools.lang(32020).encode('utf-8'),
'Container.Update(%s?action=showsRelated&actionArgs=%s)' %
(sysaddon, item['ids']['trakt'])))
cm.append((tools.lang(32069).encode(
'utf-8'
), 'XBMC.Container.Update(%s?action=showSeasons&actionArgs=%s)'
% (sysaddon, args)))
if tools.getSetting('trakt.auth') != '':
cm.append(
('Trakt Manager',
'RunPlugin(%s?action=traktManager&actionArgs=%s)' %
(sysaddon,
tools.quote(json.dumps(item['trakt_object'])))))
if tools.context_addon():
cm = []
try:
if tools.kodiVersion > 17:
item['info'].pop('seasonCount')
item['info'].pop('episodeCount')
item['info'].pop('showaliases')
except:
pass
except:
import traceback
traceback.print_exc()
continue
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
all_fanart=None,
cm=cm,
isFolder=True,
isPlayable=False,
actionArgs=args,
set_cast=set_cast,
set_ids=item['ids'])
if action == 'revokeTrakt':
from resources.lib.indexers import trakt
trakt.TraktAPI().revokeAuth()
if action == 'getSources':
try:
if tools.playList.getposition() == 0:
display_background = True
else:
display_background = False
background = windows.persistant_background()
background.setBackground(actionArgs)
background.setText(tools.lang(32045).encode('utf-8'))
if display_background:
background.show()
from resources.lib.modules import getSources
sources_window = getSources
source_results, args = database.get(sources_window.Sources().doModal,
1,
actionArgs,
seren_reload=seren_reload)
try:
del sources_window
def sync_activities(self):
update_time = str(datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S'))
trakt_activities = Trakt.TraktAPI().json_response('sync/last_activities')
if str(self.activites['all_activities']) == self.base_date and tools.getSetting('trakt.auth') != '':
# Increase the amount of concurrent tasks running during initial and Force Sync processes to speed up task
tools.showDialog.textviewer(tools.addonName, tools.lang(40133))
confirmation = tools.showDialog.yesno(tools.addonName, tools.lang(40134))
if not confirmation:
return
if trakt_activities is None:
tools.log('Unable to connect to Trakt', 'error')
return
try:
if str(self.activites['all_activities']) != self.base_date:
self.silent = True
if not self.silent:
self.progress_dialog = tools.bgProgressDialog()
self.progress_dialog.create(tools.addonName + 'Sync', 'Seren: Trakt Sync')
############################################################################################################
# CHECK FOR META REFRESH
############################################################################################################
# Meta removal should only run every 12 hours, otherwise we repeatedly dump information every run
try:
if self.activites['shows_meta_update'] == self.base_date:
self._update_activity_record('shows_meta_update', update_time)
else:
local_date = trakt_sync._parse_local_date_format(self.activites['shows_meta_update'])
local_date = local_date + timedelta(hours=2)
now = trakt_sync._utc_now_as_trakt_string()
local_date = trakt_sync._strf_local_date(local_date)
if trakt_sync._requires_update(now, local_date):
self._remove_old_meta_items('shows')
self._update_activity_record('shows_meta_update', update_time)
except:
import traceback
traceback.print_exc()
pass
try:
if self.activites['movies_meta_update'] == self.base_date:
self._update_activity_record('movies_meta_update', update_time)
else:
local_date = trakt_sync._parse_local_date_format(self.activites['movies_meta_update'])
local_date = local_date + timedelta(hours=2)
now = trakt_sync._utc_now_as_trakt_string()
local_date = trakt_sync._strf_local_date(local_date)
if trakt_sync._requires_update(now, local_date):
self._remove_old_meta_items('movies')
self._update_activity_record('movies_meta_update', update_time)
except:
import traceback
traceback.print_exc()
pass
if tools.getSetting('trakt.auth') == '':
return
if trakt_sync._requires_update(trakt_activities['all'], self.activites['all_activities']):
########################################################################################################
# SYNC HIDDEN ITEMS
########################################################################################################
try:
if not self.silent:
self.progress_dialog.update(0, 'Syncing Hidden Items')
if trakt_sync._requires_update(trakt_activities['movies']['hidden_at'],
self.activites['hidden_sync']) and \
trakt_sync._requires_update(trakt_activities['shows']['hidden_at'],
self.activites['hidden_sync']):
self._sync_hidden()
except:
import traceback
traceback.print_exc()
pass
########################################################################################################
# SYNC WATCHED ITEMS
########################################################################################################
sync_triggered = False
try:
if trakt_sync._requires_update(trakt_activities['episodes']['watched_at'],
self.activites['shows_watched']):
sync_triggered = True
self._sync_watched_episodes()
except:
import traceback
traceback.print_exc()
pass
try:
if trakt_sync._requires_update(trakt_activities['movies']['watched_at'],
self.activites['movies_watched']):
sync_triggered = True
self._sync_watched_movies()
except:
import traceback
traceback.print_exc()
pass
try:
if sync_triggered:
if not self.silent:
self.progress_dialog.update(100, 'Syncing Unwatched items')
self._sync_unwatched()
except:
import traceback
traceback.print_exc()
pass
########################################################################################################
# SYNC COLLECTION
########################################################################################################
sync_triggered = False
try:
if trakt_sync._requires_update(trakt_activities['episodes']['collected_at'],
self.activites['shows_collected']):
self._sync_collection_shows()
sync_triggered = True
except:
pass
try:
if trakt_sync._requires_update(trakt_activities['movies']['collected_at'],
self.activites['movies_collected']):
self._sync_collection_movies()
sync_triggered = True
except:
pass
try:
if sync_triggered:
if not self.silent:
self.progress_dialog.update(100, 'Syncing Uncollected items')
self._sync_uncollected()
except:
pass
self._update_activity_record('all_activities', update_time)
if self.progress_dialog is not None:
self.progress_dialog.close()
self.progress_dialog = None
except:
try:
if self.progress_dialog is not None:
self.progress_dialog.close()
self.progress_dialog = None
except:
pass
import traceback
traceback.print_exc()
pass
def post_request(self,
url,
postData,
limit=True,
refreshCheck=False,
attempts=0):
if not refreshCheck:
if limit:
url = self._append_limit(url, 0)
try:
response = requests.post(self.ApiUrl + url,
json=postData,
headers=self.headers)
self.response_headers = response.headers
if response.status_code == 404:
tools.log('Trakt returned a 404: {}'.format(url), 'error')
return None
if response.status_code == 403:
tools.log(
'Trakt 403: Forbidden - invalid API key or unapproved app'
)
tools.log(response.text)
if refreshCheck == False:
self._handle_re_auth(response)
return self.post_request(url,
postData,
limit=limit,
refreshCheck=True)
else:
tools.log(
'Failed to perform request even after token refresh',
'error')
if response.status_code == 401:
tools.log('Trakt 401: Unauthorized - OAuth must be provided')
tools.log(response.text)
return
if response.status_code > 499:
if attempts < 5:
attempts += 1
tools.log(
'Failed to perform Trakt POST request, re-trying. Attempts: {}'
.format(attempts), 'error')
return self.post_request(url, postData, limit, True,
attempts)
else:
tools.log(
'Trakt failed to reply on multiple attempts, URL: {}'.
format(url), 'error')
return None
except requests.exceptions.ConnectionError:
return
except not requests.exceptions.ConnectionError:
tools.showDialog.ok(tools.addonName, tools.lang(32035))
return
return response.text
def auth(self):
url = 'https://api.trakt.tv/oauth/device/code'
postData = {'client_id': self.ClientID}
response = requests.post(url, data=postData)
if not response.ok:
tools.showDialog.ok(tools.addonName, tools.lang(40113))
return
response = json.loads(response.text)
try:
user_code = response['user_code']
device = response['device_code']
interval = int(response['interval'])
expiry = int(response['expires_in'])
except:
tools.showDialog.ok(tools.addonName, tools.lang(32032))
return
currentTime = 0
tools.copy2clip(user_code)
tools.progressDialog.create(
tools.addonName + ': ' + tools.lang(32031),
tools.lang(32024) +
tools.colorString('https://trakt.tv/activate \n') +
tools.lang(32025) + tools.colorString(user_code) + "\n" +
tools.lang(32071))
tools.progressDialog.update(100)
while currentTime < (expiry - interval):
if tools.progressDialog.iscanceled():
tools.progressDialog.close()
return
progressPercent = int(100 - ((float(currentTime) / expiry) * 100))
tools.progressDialog.update(progressPercent)
sleep(interval)
postData = {
'code': device,
'client_id': self.ClientID,
'client_secret': self.ClientSecret
}
url = 'https://api.trakt.tv/oauth/device/token'
response = requests.post(url, data=postData)
if '200' in str(response):
response = json.loads(response.text)
tools.setSetting('trakt.auth', response['access_token'])
tools.setSetting('trakt.refresh', response['refresh_token'])
self.AccessToken = response['access_token']
self.headers = {
'trakt-api-version': '2',
'trakt-api-key': self.ClientID,
'content-type': 'application/json'
}
if not self.AccessToken is '':
self.headers[
'Authorization'] = 'Bearer %s' % self.AccessToken
username = self.get_username()
tools.setSetting('trakt.username', username)
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName,
'Sucessfully authenticated with Trakt')
# Synchronise Trakt Database with new user
from resources.lib.modules.trakt_sync import activities
database = activities.TraktSyncDatabase()
if database.activites['trakt_username'] != username:
database.clear_user_information()
database.flush_activities(False)
database._build_sync_activities()
database.set_trakt_user(username)
tools.execute(
'RunPlugin("plugin://plugin.video.%s/?action=syncTraktActivities")'
% tools.addonName.lower())
break
if '400' in str(response):
pass
else:
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName, tools.lang(32032))
break
def _get_display_name(type):
if type == 'movie':
return tools.lang(40279)
else:
return tools.lang(40276)
def discoverShows(self):
########Begin Soul TV Modifications
tools.addDirectoryItem(tools.lang(99998), 'showsGary', '', '')
tools.addDirectoryItem(tools.lang(99997), 'showsNetflix', '', '')
tools.addDirectoryItem(tools.lang(99995), 'showsHulu', '', '')
tools.addDirectoryItem(tools.lang(99996), 'showsAmazon', '', '')
tools.addDirectoryItem(tools.lang(99982), 'showsDisneyP', '', '')
tools.addDirectoryItem(tools.lang(99981), 'showsAppleP', '', '')
########End Soul TV Modifications
tools.addDirectoryItem(tools.lang(32007), 'showsPopular&page=1')
if tools.getSetting('trakt.auth') is not '':
tools.addDirectoryItem(tools.lang(32008), 'showsRecommended')
# tools.addDirectoryItem('This Years Most Popular', '')
tools.addDirectoryItem(tools.lang(32009), 'showsTrending&page=1')
tools.addDirectoryItem(tools.lang(32067), 'showsNew')
tools.addDirectoryItem(tools.lang(32010), 'showsPlayed&page=1')
tools.addDirectoryItem(tools.lang(32011), 'showsWatched&page=1')
tools.addDirectoryItem(tools.lang(32012), 'showsCollected&page=1')
tools.addDirectoryItem(tools.lang(32013), 'showsAnticipated&page=1')
tools.addDirectoryItem(tools.lang(32014), 'showsUpdated&page=1')
tools.addDirectoryItem(tools.lang(40121), 'showsNetworks')
tools.addDirectoryItem(tools.lang(40123), 'showYears')
tools.addDirectoryItem(tools.lang(32062), 'tvGenres')
tools.addDirectoryItem(tools.lang(40151), 'showsByActor')
########Begin Soul TV Modifications
# tools.addDirectoryItem(tools.lang(99994), 'soulSpotlight', '', '')
# tools.addDirectoryItem(tools.lang(99993), 'showssoulSpotlight', '', '')
# tools.addDirectoryItem(tools.lang(99991), 'showssoulCurated', '', '')
# tools.addDirectoryItem(tools.lang(99983), 'showsPixelHunter', '', '')
########End Soul TV Modifications
# show genres is now labeled as tvGenres to support genre icons in skins
if tools.getSetting('searchHistory') == 'false':
tools.addDirectoryItem(tools.lang(32016), 'showsSearch', isFolder=True, isPlayable=False)
else:
tools.addDirectoryItem(tools.lang(32016), 'showsSearchHistory')
tools.closeDirectory('addons')
def traktManager(self, actionArgs):
item_information = tools.get_item_information(actionArgs)
trakt_object = item_information['trakt_object']
trakt_id = item_information['ids']['trakt']
actionArgs = json.loads(tools.unquote(actionArgs))
type = actionArgs['item_type'].lower()
display_type = self._get_display_name(type)
if trakt_object is None:
tools.showDialog.notification(tools.addonName, tools.lang(40264))
dialog_list = []
if item_information['info']['playcount'] > 0:
dialog_list.append(tools.lang(40270))
else:
dialog_list.append(tools.lang(40269))
if 'movies' in trakt_object:
from resources.lib.modules.trakt_sync.movies import TraktSyncDatabase
collection = [
i['trakt_id']
for i in TraktSyncDatabase().get_collected_movies()
]
if trakt_id in collection:
dialog_list.append(tools.lang(40266) % display_type)
else:
dialog_list.append(tools.lang(40265) % display_type)
else:
from resources.lib.modules.trakt_sync.shows import TraktSyncDatabase
collection = TraktSyncDatabase().get_collected_episodes()
collection = [i for i in collection if i is not None]
collection = list(set([i['show_id'] for i in collection]))
trakt_id = trakt_object['show_id'] = actionArgs['trakt_id']
if trakt_id in collection:
dialog_list.append(tools.lang(40266) % display_type)
else:
dialog_list.append(tools.lang(40265) % display_type)
pass
standard_list = [
tools.lang(40267),
tools.lang(40268),
tools.lang(40271),
tools.lang(40272),
tools.lang(40273) % display_type,
tools.lang(40274)
]
for i in standard_list:
dialog_list.append(i)
if not type in ['show', 'season']:
dialog_list.append(tools.lang(40275))
selection = tools.showDialog.select(
'{}: {}'.format(tools.addonName, tools.lang(40280)), dialog_list)
if selection == -1:
return
thread = None
if dialog_list[selection] == tools.lang(40265) % display_type:
thread = threading.Thread(target=self.addToCollection,
args=(trakt_object, ))
elif dialog_list[selection] == tools.lang(40266) % display_type:
thread = threading.Thread(target=self.removeFromCollection,
args=(trakt_object, ))
elif dialog_list[selection] == tools.lang(40267):
thread = threading.Thread(target=self.addToWatchList,
args=(trakt_object, ))
elif dialog_list[selection] == tools.lang(40268):
thread = threading.Thread(target=self.removeFromWatchlist,
args=(trakt_object, ))
elif dialog_list[selection] == tools.lang(40269):
thread = threading.Thread(target=self.markWatched,
args=(trakt_object, actionArgs))
elif dialog_list[selection] == tools.lang(40270):
thread = threading.Thread(target=self.markUnwatched,
args=(trakt_object, actionArgs))
elif dialog_list[selection] == tools.lang(40271):
self.addToList(trakt_object)
elif dialog_list[selection] == tools.lang(40272):
self.removeFromList(trakt_object)
elif dialog_list[selection] == tools.lang(40273) % display_type:
self.hideItem(actionArgs)
elif dialog_list[selection] == tools.lang(40274):
self.refresh_meta_information(trakt_object)
elif dialog_list[selection] == tools.lang(40275):
self.removePlaybackHistory(trakt_object)
else:
return
if thread is not None:
thread.start()
return
def commonListBuilder(self, traktList, nextPath=None, title_appends=None):
if len(traktList) == 0:
return
if 'movie' in traktList[0]:
traktList = [i['movie'] for i in traktList]
for item in traktList:
self.threadList.append(
Thread(target=self.tmdbListWorker, args=(item, )))
self.runThreads()
self.itemList = tools.sort_list_items(self.itemList, traktList)
if tools.getSetting('trakt.auth') != '':
traktWatched = trakt.json_response('sync/watched/movies')
for listItem in self.itemList:
for i in traktWatched:
if i['movie']['ids']['trakt'] == listItem['ids']['trakt']:
listItem['info']['playcount'] = i['plays']
for item in self.itemList:
try:
# Add Arguments to pass with item
args = {}
args['title'] = item['info']['title']
args['year'] = item['info']['year']
args['ids'] = item['ids']
args['fanart'] = item['art']['fanart']
args['info'] = item['info']
args['art'] = item['art']
name = item['info']['title']
if title_appends is not None:
name = '%s - %s' % (name,
title_appends[item['ids']['trakt']])
item['info']['title'] = item['info']['originaltitle'] = name
args = tools.quote(json.dumps(args))
# Begin Building Context Menu Items
cm = []
cm.append((
tools.lang(32020).encode('utf-8'),
'Container.Update(%s?action=moviesRelated&actionArgs=%s)' %
(sysaddon, item['ids']['trakt'])))
cm.append((tools.lang(32066).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&source_select=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(33022).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&seren_reload=true&actionArgs=%s)'
% (sysaddon, args)))
if tools.getSetting('trakt.auth') != '':
cm.append(
('Trakt Manager',
'RunPlugin(%s?action=traktManager&actionArgs=%s)' %
(sysaddon,
tools.quote(json.dumps(item['trakt_object'])))))
if tools.context_addon():
cm = []
except:
continue
if item is None: continue
tools.addDirectoryItem(name,
'getSources',
item['info'],
item['art'],
cm=cm,
isFolder=False,
isPlayable=True,
actionArgs=args,
set_ids=item['ids'])
def episodeListBuilder(self,
traktList,
showInfo,
smartPlay=False,
info_only=False,
hide_unaired=False):
self.threadList = []
try:
play_list = []
if len(traktList) == 0: return
for item in traktList:
# if tools.getSetting('general.metalocation') == '1':
if 1 == 1:
self.threadList.append(
Thread(target=self.tvdbEpisodeWorker,
args=(item, showInfo)))
else:
self.threadList.append(
Thread(target=self.tmdbEpisodeWorker,
args=(item, showInfo)))
self.runThreads()
if smartPlay is False and tools.getSetting('trakt.auth') != '':
try:
traktWatched = trakt.json_response(
'shows/%s/progress/watched' %
showInfo['showInfo']['ids']['trakt'])
except:
pass
self.itemList = [x for x in self.itemList if x is not None]
try:
self.itemList = sorted(self.itemList,
key=lambda k: k['info']['episode'])
except:
pass
if info_only == True:
return
for item in self.itemList:
if hide_unaired:
try:
currentDate = datetime.datetime.today().date()
airdate = item['info']['premiered']
if airdate == '':
continue
airdate = tools.datetime_workaround(airdate)
if airdate > currentDate:
continue
except:
import traceback
traceback.print_exc()
pass
cm = []
action = ''
if item is None: continue
if smartPlay is False and tools.getSetting('trakt.auth') != '':
item['info']['playcount'] = 0
try:
for season in traktWatched['seasons']:
if season['number'] == item['info']['season']:
for episode in season['episodes']:
if episode['number'] == item['info'][
'episode'] and episode[
'completed'] == True:
item['info']['playcount'] = 1
except:
pass
try:
args = {'showInfo': {}, 'episodeInfo': {}}
if tools.getSetting('smartplay.playlistcreate'
) == 'true' and smartPlay is False:
action = 'smartPlay'
playable = False
else:
playable = True
action = 'getSources'
args['showInfo'] = showInfo['showInfo']
args['episodeInfo']['info'] = item['info']
args['episodeInfo']['art'] = item['art']
args['episodeInfo']['ids'] = item['ids']
name = item['info']['title']
args = tools.quote(json.dumps(args, sort_keys=True))
except:
import traceback
traceback.print_exc()
continue
cm.append((tools.lang(33022).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&seren_reload=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(32066).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&source_select=true&actionArgs=%s)'
% (sysaddon, args)))
if tools.getSetting('trakt.auth') != '':
cm.append(
('Trakt Manager',
'RunPlugin(%s?action=traktManager&actionArgs=%s)' %
(sysaddon,
tools.quote(json.dumps(item['trakt_object'])))))
if tools.context_addon():
cm = []
if tools.getSetting(
'premiumize.enabled'
) == 'true' and tools.getSetting('premiumize.pin') != '':
cm.append(
(tools.lang(32068).encode('utf-8'),
'XBMC.RunPlugin(%s?action=filePicker&actionArgs=%s)' %
(sysaddon, args)))
if smartPlay is False:
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
cm=cm,
isFolder=False,
isPlayable=playable,
actionArgs=args,
set_ids=item['ids'])
else:
play_list.append(
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
isFolder=False,
isPlayable=playable,
actionArgs=args,
smart_play=True,
set_ids=item['ids']))
if smartPlay is True:
return play_list
except:
import traceback
traceback.print_exc()
def discoverMovies(self):
tools.addDirectoryItem(tools.lang(32007), 'moviesPopular&page=1')
if tools.getSetting('trakt.auth') is not '':
tools.addDirectoryItem(tools.lang(32008), 'moviesRecommended')
tools.addDirectoryItem(tools.lang(32009), 'moviesTrending&page=1')
tools.addDirectoryItem(tools.lang(32010), 'moviesPlayed&page=1')
tools.addDirectoryItem(tools.lang(32011), 'moviesWatched&page=1')
tools.addDirectoryItem(tools.lang(32012), 'moviesCollected&page=1')
tools.addDirectoryItem(tools.lang(32013), 'moviesAnticipated&page=1')
tools.addDirectoryItem(tools.lang(32015), 'moviesBoxOffice')
tools.addDirectoryItem(tools.lang(32014), 'moviesUpdated&page=1')
tools.addDirectoryItem(tools.lang(32062), 'movieGenres&page=1')
tools.addDirectoryItem(tools.lang(40123), 'movieYears')
tools.addDirectoryItem(tools.lang(40151), 'movieByActor')
# tools.addDirectoryItem('Years', 'movieYears')
if tools.getSetting('searchHistory') == 'false':
tools.addDirectoryItem(tools.lang(32016),
'moviesSearch',
isFolder=True,
isPlayable=False)
else:
tools.addDirectoryItem(tools.lang(32016), 'moviesSearchHistory')
tools.closeDirectory('addons')
def discoverShows(self):
tools.addDirectoryItem(
tools.lang(32007).encode('utf-8'), 'showsPopular&page=1', '', '')
if tools.getSetting('trakt.auth') is not '':
tools.addDirectoryItem(
tools.lang(32008).encode('utf-8'), 'showsRecommended', '', '')
tools.addDirectoryItem(
tools.lang(32009).encode('utf-8'), 'showsTrending&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32067).encode('utf-8'), 'showsNew', '', '')
tools.addDirectoryItem(
tools.lang(32010).encode('utf-8'), 'showsPlayed&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32011).encode('utf-8'), 'showsWatched&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32012).encode('utf-8'), 'showsCollected&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32013).encode('utf-8'), 'showsAnticipated&page=1', '',
'')
tools.addDirectoryItem(
tools.lang(32014).encode('utf-8'), 'showsUpdated&page=1', '', '')
tools.addDirectoryItem(
tools.lang(32062).encode('utf-8'), 'showGenres', '', '')
tools.addDirectoryItem(
tools.lang(32016).encode('utf-8'), 'showsSearch', '', '')
tools.closeDirectory('addons', cacheToDisc=True)
def real_debrid_downloader(self, torrent_object):
from resources.lib.common import source_utils
tools.showDialog.notification(tools.addonName,
tools.lang(32072).encode('utf-8'))
current_percent = 0
debrid = real_debrid.RealDebrid()
magnet = debrid.addMagnet(torrent_object['magnet'])
info = debrid.torrentInfo(magnet['id'])
torrent_id = info['id']
database.add_assist_torrent(torrent_id, 'real_debrid', 'queued',
torrent_object['release_title'],
str(current_percent))
key_list = []
for file in info['files']:
filename = file['path']
key = file['id']
if any(filename.lower().endswith(extension)
for extension in source_utils.COMMON_VIDEO_EXTENSIONS):
key_list.append(key)
break
debrid.torrentSelect(torrent_id, ','.join(key_list))
downloading_status = ['queued', 'downloading']
current_percent = 0
timestamp = time.time()
while not monitor.abortRequested():
if monitor.waitForAbort(120):
break
try:
info = debrid.torrentInfo(torrent_id)
if info['status'] == 'downloaded':
tools.showDialog.notification(
tools.addonName + ': %s' % self.title,
tools.lang(32072).encode('utf-8') + ' %s' % self.title,
time=5000)
database.add_assist_torrent(
torrent_id, 'real_debrid', 'finished',
torrent_object['release_title'], str(current_percent))
debrid.deleteTorrent(torrent_id)
break
if info['status'] in downloading_status:
if info['progress'] == current_percent:
if timestamp == (time.time() + 10800):
database.add_assist_torrent(
torrent_id, 'real_debrid', 'failed',
torrent_object['release_title'],
str(current_percent))
debrid.deleteTorrent(torrent_id)
tools.showDialog.notification(
tools.addonName,
'Cache assist for %s has failed due to no progress'
% self.title)
break
continue
else:
database.add_assist_torrent(
torrent_id, 'real_debrid', 'downloading',
torrent_object['release_title'],
str(current_percent))
current_percent = info['progress']
continue
else:
database.add_assist_torrent(
torrent_id, 'real_debrid', 'failed',
torrent_object['release_title'], str(current_percent))
debrid.deleteTorrent(torrent_id)
tools.log(
'Could not create cache for magnet- %s' %
torrent_object['magnet'], 'info')
tools.showDialog.notification(
tools.addonName,
'Cache assist for %s has failed according to Real Debrid'
% self.title)
break
except:
debrid.deleteTorrent(torrent_id)
def directToEpisodeBuilder(self, traktList, sort=None):
self.threadList = []
traktWatched = trakt.json_response('sync/watched/shows')
try:
if len(traktList) == 0: return
for item in traktList:
# if tools.getSetting('general.metalocation') == '1':
if 1 == 1:
self.threadList.append(
Thread(target=self.tvdbEpisodeWorker,
args=(item['episode'], item['show'])))
else:
self.threadList.append(
Thread(target=self.tmdbEpisodeWorker,
args=(item[0], item[1])))
self.runThreads()
self.itemList = [i for i in self.itemList if i is not None]
if sort is not None:
sorted_list = []
for sort_id in sort['id_list']:
for menu_item in self.itemList:
if menu_item[sort['type']]['ids']['trakt'] == sort_id:
sorted_list.append(menu_item)
self.itemList = sorted_list
else:
self.itemList = sorted(self.itemList,
key=lambda i: tools.datetime_workaround(
i['info']['premiered']),
reverse=True)
for item in self.itemList:
if item is None:
continue
try:
currentDate = datetime.datetime.today().date()
airdate = item['info']['premiered']
if airdate == '':
continue
airdate = tools.datetime_workaround(airdate)
if airdate > currentDate:
continue
except:
import traceback
traceback.print_exc()
pass
if item['info'].get('title', '') == '':
continue
cm = []
action = ''
if tools.getSetting('trakt.auth') != '':
try:
item['info']['playcount'] = 0
for show in traktWatched:
if str(show['show']['ids']['trakt']) == str(
item['showInfo']['ids']['trakt']):
for season in show['seasons']:
if str(season['number']) == str(
item['info']['season']):
for episode in season['episodes']:
if str(episode['number']) == str(
item['info']['episode']):
if episode['plays'] > 0:
item['info'][
'playcount'] = 1
except:
pass
try:
args = {'showInfo': {}, 'episodeInfo': {}}
if tools.getSetting('smartplay.playlistcreate') == 'true':
action = 'smartPlay'
playable = False
else:
playable = True
action = 'getSources'
args['showInfo'] = item['showInfo']
args['episodeInfo']['info'] = item['info']
args['episodeInfo']['art'] = item['art']
args['episodeInfo']['ids'] = item['ids']
name = item['info']['title']
args = tools.quote(json.dumps(args, sort_keys=True))
cm.append((tools.lang(32069).encode(
'utf-8'
), 'XBMC.Container.Update(%s?action=showSeasons&actionArgs=%s)'
% (sysaddon,
tools.quote(json.dumps(item['showInfo'])))))
cm.append((tools.lang(32066).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&source_select=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(33022).encode(
'utf-8'
), 'PlayMedia(%s?action=getSources&seren_reload=true&actionArgs=%s)'
% (sysaddon, args)))
if tools.getSetting('trakt.auth') != '':
cm.append((
'Trakt Manager',
'RunPlugin(%s?action=traktManager&actionArgs=%s)' %
(sysaddon,
tools.quote(json.dumps(item['trakt_object'])))))
if tools.context_addon():
cm = []
if tools.getSetting(
'premiumize.enabled'
) == 'true' and tools.getSetting('premiumize.pin') != '':
cm.append((tools.lang(32068).encode(
'utf-8'
), 'XBMC.RunPlugin(%s?action=filePicker&actionArgs=%s)'
% (sysaddon, args)))
except:
import traceback
traceback.print_exc()
continue
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
cm=cm,
isFolder=False,
isPlayable=playable,
actionArgs=args,
set_ids=item['ids'])
except:
import traceback
traceback.print_exc()
def auth(self):
url = 'https://api.trakt.tv/oauth/device/code'
postData = {'client_id': self.ClientID}
response = requests.post(url, data=postData)
if not response.ok:
tools.showDialog.ok(tools.addonName,
tools.lang(40113).encode('utf-8'))
return
response = json.loads(response.text)
try:
user_code = response['user_code']
device = response['device_code']
interval = int(response['interval'])
expiry = int(response['expires_in'])
except:
tools.showDialog.ok(tools.addonName,
tools.lang(32032).encode('utf-8'))
return
currentTime = 0
tools.copy2clip(user_code)
tools.progressDialog.create(
tools.addonName + ': ' + tools.lang(32031).encode('utf-8'),
tools.lang(32024).encode('utf-8') +
tools.colorString('https://trakt.tv/activate \n') +
tools.lang(32025).encode('utf-8') + tools.colorString(user_code) +
"\n" + tools.lang(32071).encode('utf-8'))
tools.progressDialog.update(100)
while currentTime < (expiry - interval):
if tools.progressDialog.iscanceled():
tools.progressDialog.close()
return
progressPercent = int(100 - ((float(currentTime) / expiry) * 100))
tools.progressDialog.update(progressPercent)
sleep(interval)
postData = {
'code': device,
'client_id': self.ClientID,
'client_secret': self.ClientSecret
}
url = 'https://api.trakt.tv/oauth/device/token'
response = requests.post(url, data=postData)
if '200' in str(response):
response = json.loads(response.text)
tools.setSetting('trakt.auth', response['access_token'])
tools.setSetting('trakt.refresh', response['refresh_token'])
self.headers[
'Authorization'] = 'Bearer %s' % response['access_token']
username = self.get_username()
tools.setSetting('trakt.username', username)
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName,
'Sucessfully authenticated with Trakt')
break
if '400' in str(response):
pass
else:
tools.showDialog.ok(tools.addonName,
tools.lang(32032).encode('utf-8'))
tools.progressDialog.close()
tools.showDialog.ok(tools.addonName,
tools.lang(32033).encode('utf-8'))
def malformed_output():
tools.showDialog.ok(tools.addonName, '%s - %s' % (tools.lang(40319)), tools.lang(40320))
tools.log('Source pack is malformed, please check and correct issue in the meta file')
