def __init__(self):
self.apiKey = tools.getSetting('tvdb.apikey')
if self.apiKey == '':
self.apiKey = "43VPI0R8323FB7TI"
self.baseUrl = 'https://api.thetvdb.com/'
self.jwToken = tools.getSetting('tvdb.jw')
self.headers = {'Content-Type': 'application/json'}
self.art = {}
self.info = {}
self.episode_summary = {}
self.cast = []
self.baseImageUrl = 'https://www.thetvdb.com/banners/'
self.threads = []
self.fanartart = {}
self.tvshows_poster_limit = int(
tools.getSetting('tvshows.poster_limit'))
self.tvshows_fanart_limit = int(
tools.getSetting('tvshows.fanart_limit'))
self.tvshows_keyart_limit = int(
tools.getSetting('tvshows.keyart_limit'))
self.tvshows_characterart_limit = int(
tools.getSetting('tvshows.characterart_limit'))
self.tvshows_banner = tools.getSetting('tvshows.banner')
self.season_poster = tools.getSetting('season.poster')
self.season_banner = tools.getSetting('season.banner')
self.season_landscape = tools.getSetting('season.landscape')
self.season_fanart = tools.getSetting('season.fanart')
self.episode_fanart = tools.getSetting('episode.fanart')
self.tvshows_prefer_fanart = tools.getSetting(
'tvshows.preferedsource') == '0'
if tools.fanart_api_key == '':
self.fanart_support = False
else:
self.fanart_support = True
if self.jwToken is not '':
self.headers['Authorization'] = 'Bearer %s' % self.jwToken
else:
self.newToken()
self.headers['Authorization'] = 'Bearer %s' % self.jwToken
def __init__(self):
self.agent_identifier = tools.addonName
self.apikey = tools.getSetting('alldebrid.apikey')
def magnetToLink(self, torrent, args):
try:
if torrent['package'] == 'single':
return self.singleMagnetToLink(torrent['magnet'])
hash = str(
re.findall(r'btih:(.*?)&', torrent['magnet'])[0].lower())
hashCheck = self.checkHash(hash)
torrent = self.addMagnet(torrent['magnet'])
episodeStrings, seasonStrings = source_utils.torrentCacheStrings(
args)
key_list = []
for storage_variant in hashCheck[hash]['rd']:
file_inside = False
key_list = []
bad_storage = False
for key, value in storage_variant.items():
filename = storage_variant[key]['filename']
if not any(
filename.endswith(extension) for extension in
source_utils.COMMON_VIDEO_EXTENSIONS):
bad_storage = True
continue
else:
key_list.append(key)
if any(
source_utils.cleanTitle(episodeString) in
source_utils.cleanTitle(filename)
for episodeString in episodeStrings):
file_inside = True
if file_inside is False or bad_storage is True:
continue
else:
break
if len(key_list) == 0:
self.deleteTorrent(torrent['id'])
return None
key_list = ','.join(key_list)
self.torrentSelect(torrent['id'], key_list)
link = self.torrentInfo(torrent['id'])
file_index = None
for idx, i in enumerate(
[i for i in link['files'] if i['selected'] == 1]):
if any(
source_utils.cleanTitle(episodeString) in
source_utils.cleanTitle(i['path'].split('/')[-1])
for episodeString in episodeStrings):
file_index = idx
if file_index is None:
self.deleteTorrent(torrent['id'])
return None
link = link['links'][file_index]
link = self.unrestrict_link(link)
if link.endswith('rar'):
link = None
if tools.getSetting('rd.autodelete') == 'true':
self.deleteTorrent(torrent['id'])
return link
except:
import traceback
traceback.print_exc()
self.deleteTorrent(torrent['id'])
return None
def mixedEpisodeBuilder(self,
trakt_list,
sort=None,
hide_watched=False,
smartPlay=False,
hide_unaired=True,
prepend_date=False):
self.threadList = []
try:
if len(trakt_list) == 0:
tools.log('We received no titles to build a list', 'error')
return
self.itemList = TraktSyncDatabase().get_episode_list(trakt_list)
self.itemList = [
x for x in self.itemList if x is not None and 'info' in x
]
self.itemList = [
i for i in self.itemList
if 'info' in i and i['info'].get('premiered', None) is not None
]
if sort is None:
self.itemList = sorted(
self.itemList,
key=lambda i: tools.datetime_workaround(
i['info']['premiered'], tools.trakt_gmt_format, False),
reverse=True)
elif sort is not False:
sort_list = []
for trakt_id in sort['id_list']:
try:
if not sort['type']:
item = [
i for i in self.itemList
if i['ids']['trakt'] == trakt_id
][0]
else:
item = [
i for i in self.itemList
if i[sort['type']]['ids']['trakt'] == trakt_id
][0]
sort_list.append(item)
except IndexError:
continue
except:
import traceback
traceback.print_exc()
self.itemList = sort_list
item_list = []
for item in self.itemList:
if item is None:
continue
if item['info'].get('title', '') == '':
continue
if hide_watched and item['info']['playcount'] != 0:
continue
cm = []
try:
name = tools.display_string(item['info']['title'])
if not self.is_aired(
item['info']) and hide_unaired is True:
continue
elif not self.is_aired(item['info']):
name = tools.colorString(name, 'red')
name = tools.italic_string(name)
item['info']['title'] = name
item['info'] = tools.clean_air_dates(item['info'])
args = {'showInfo': {}, 'episodeInfo': {}}
if tools.getSetting('smartplay.playlistcreate'
) == 'true' and not smartPlay:
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']
if self.title_appends == 'true':
name = "%s: %sx%s %s" % (
tools.colorString(
args['showInfo']['info']['tvshowtitle']),
tools.display_string(
item['info']['season']).zfill(2),
tools.display_string(
item['info']['episode']).zfill(2),
tools.display_string(item['info']['title']))
if prepend_date:
release_day = tools.datetime_workaround(
item['info']['aired'])
release_day = release_day.strftime('%d %b')
name = '[%s] %s' % (release_day, name)
args = tools.quote(json.dumps(args, sort_keys=True))
cm.append((tools.lang(
32069
), 'XBMC.Container.Update(%s?action=showSeasons&actionArgs=%s)'
% (sysaddon,
tools.quote(json.dumps(str(
item['showInfo']))))))
cm.append((tools.lang(
32066
), 'PlayMedia(%s?action=getSources&source_select=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(
33022
), '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(str(
item['trakt_object']))))))
if tools.context_addon():
cm = []
if tools.getSetting(
'premiumize.enabled'
) == 'true' and tools.getSetting('premiumize.pin') != '':
cm.append((tools.lang(
32068
), 'XBMC.RunPlugin(%s?action=filePicker&actionArgs=%s)'
% (sysaddon, args)))
item['info']['title'] = item['info'][
'originaltitle'] = name
item_list.append(
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
isFolder=False,
isPlayable=playable,
actionArgs=args,
bulk_add=True,
set_ids=item['ids'],
cm=cm))
except:
import traceback
traceback.print_exc()
continue
if smartPlay is True:
return item_list
else:
tools.addMenuItems(syshandle, item_list, len(item_list))
except:
import traceback
traceback.print_exc()
def resolve(self, sources, args, pack_select=False):
try:
stream_link = None
loop_count = 0
# Begin resolving links
for i in sources:
debrid_provider = i.get('debrid_provider',
'None').replace('_', ' ')
loop_count += 1
try:
if self.is_canceled():
self.close()
return
if 'size' in i:
self.setProperty('source_size',
tools.source_size_display(i['size']))
self.setProperty('release_title',
tools.display_string(i['release_title']))
self.setProperty('debrid_provider', debrid_provider)
self.setProperty('source_provider', i['provider'])
self.setProperty('source_resolution', i['quality'])
self.setProperty('source_info', " ".join(i['info']))
self.setProperty('source_type', i['type'])
if i['type'] == 'torrent':
stream_link = self.resolve_source(
self.resolvers[i['debrid_provider']], i, args,
pack_select)
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' or i['type'] == 'cloud':
if i['url'] is None:
continue
if i['type'] == 'cloud' and i[
'debrid_provider'] == 'premiumize':
selected_file = Premiumize.Premiumize(
).item_details(i['url'])
if tools.getSetting(
'premiumize.transcoded') == 'true':
url = selected_file['stream_link']
else:
url = selected_file['link']
self.return_data = url
self.close()
return
if 'provider_imports' in i:
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 'debrid_provider' in i:
stream_link = self.resolve_source(
self.resolvers[i['debrid_provider']], i, args,
pack_select)
if stream_link is None:
continue
else:
try:
requests.head(stream_link, timeout=1)
except requests.exceptions.RequestException:
tools.log(
'Head Request failed link likely dead, skipping'
)
continue
elif i['url'].startswith('http'):
try:
ext = i['url'].split('?')[0]
ext = ext.split('&')[0]
ext = ext.split('|')[0]
ext = ext.rsplit('.')[-1]
ext = ext.replace('/', '').lower()
if ext == 'rar': raise Exception()
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,
timeout=10)
if not live_check.status_code == 200:
tools.log(
'Head Request failed link likely dead, skipping'
)
continue
stream_link = i['url']
except:
import traceback
traceback.print_exc()
stream_link = None
elif tools.file_exists(i['url']):
stream_link = i['url']
if stream_link is None:
continue
else:
if stream_link.endswith('.rar'):
continue
self.return_data = stream_link
self.close()
return
continue
except:
import traceback
traceback.print_exc()
continue
self.close()
return
except:
import traceback
traceback.print_exc()
self.close()
return
def sync_activities(self, silent=False):
sync_errors = False
update_time = str(datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S'))
tools.log('STARTING SYNC')
self._refresh_activites()
if not silent and \
str(self.activites['all_activities']) == self.base_date and \
tools.getSetting('trakt.auth') != '':
tools.showDialog.notification(tools.addonName, tools.lang(40133))
# Give the people time to read the damn notification
tools.kodi.sleep(500)
try:
if str(self.activites['all_activities']) == self.base_date:
self.silent = False
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:
sync_errors = True
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:
sync_errors = True
import traceback
traceback.print_exc()
pass
if tools.getSetting('trakt.auth') == '':
if self.progress_dialog is not None:
self.progress_dialog.close()
self.progress_dialog = None
self._update_activity_record('all_activities', update_time)
return
trakt_activities = Trakt.TraktAPI().json_response(
'sync/last_activities')
if trakt_activities is None:
tools.log('Unable to connect to Trakt', 'error')
if self.progress_dialog is not None:
self.progress_dialog.close()
self.progress_dialog = None
return True
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:
sync_errors = True
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:
sync_errors = True
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:
sync_errors = True
import traceback
traceback.print_exc()
pass
try:
if sync_triggered:
if not self.silent:
self.progress_dialog.update(
0, 'Syncing Unwatched items')
self._sync_unwatched()
except:
sync_errors = True
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:
sync_errors = True
import traceback
traceback.print_exc()
pass
try:
if trakt_sync._requires_update(
trakt_activities['movies']['collected_at'],
self.activites['movies_collected']):
self._sync_collection_movies()
sync_triggered = True
except:
sync_errors = True
import traceback
traceback.print_exc()
pass
try:
if sync_triggered:
if not self.silent:
self.progress_dialog.update(
0, 'Syncing Uncollected items')
self._sync_uncollected()
except:
sync_errors = True
import traceback
traceback.print_exc()
pass
########################################################################################################
# SYNC BOOKMARK
########################################################################################################
sync_triggered = False
try:
if trakt_sync._requires_update(
trakt_activities['episodes']['paused_at'],
self.activites['episodes_bookmarked']):
cursor = self._get_cursor()
cursor.execute('DELETE FROM bookmark WHERE 1=1')
cursor.connection.commit()
cursor.close()
self._sync_bookmarks('episodes')
sync_triggered = True
except:
sync_errors = True
import traceback
traceback.print_exc()
pass
try:
if trakt_sync._requires_update(
trakt_activities['movies']['paused_at'],
self.activites['movies_bookmarked']):
self._sync_bookmarks('movies')
sync_triggered = True
except:
sync_errors = True
import traceback
traceback.print_exc()
pass
try:
if sync_triggered:
if not self.silent:
self.progress_dialog.update(
100, 'Syncing bookmarked items')
except:
sync_errors = True
import traceback
traceback.print_exc()
pass
########################################################################################################
# SYNC LISTS
########################################################################################################
lists_to_update = []
try:
trakt_api = Trakt.TraktAPI()
lists = trakt_api.json_response('users/me/lists',
limit=True,
limitOverride=500)
lists.extend([
i['list'] for i in trakt_api.json_response(
'users/likes/lists', limit=True, limitOverride=500)
])
for item in lists:
if not trakt_sync._requires_update(
item['updated_at'],
self.activites['lists_sync']):
continue
lists_to_update.append(item)
self._sync_lists(lists_to_update)
except:
sync_errors = True
import traceback
traceback.print_exc()
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
return sync_errors
def seasonListBuilder(self, show_id, smartPlay=False):
self.itemList = TraktSyncDatabase().get_season_list(show_id)
self.itemList = [
x for x in self.itemList if x is not None and 'info' in x
]
self.itemList = sorted(self.itemList,
key=lambda k: k['info']['season'])
if len(self.itemList) == 0:
tools.log('We received no titles to build a list', 'error')
return
hide_specials = False
if tools.getSetting('general.hideSpecials') == 'true':
hide_specials = True
item_list = []
for item in self.itemList:
try:
if hide_specials and int(item['info']['season']) == 0:
continue
args = {'showInfo': {}, 'seasonInfo': {}}
action = 'seasonEpisodes'
args['showInfo'] = item['showInfo']
args['seasonInfo']['info'] = item['info']
args['seasonInfo']['art'] = item['art']
args['seasonInfo']['ids'] = item['ids']
item['trakt_object']['show_id'] = item['showInfo']['ids'][
'trakt']
name = item['info']['season_title']
if not self.is_aired(
item['info']) or 'aired' not in item['info']:
if tools.getSetting('general.hideUnAired') == 'true':
continue
name = tools.colorString(name, 'red')
name = tools.italic_string(name)
item['info']['title'] = name
item['info'] = tools.clean_air_dates(item['info'])
args = tools.quote(json.dumps(args, sort_keys=True))
except:
import traceback
traceback.print_exc()
continue
if smartPlay is True:
return args
cm = []
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 = []
item_list.append(
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
cm=cm,
isFolder=True,
isPlayable=False,
actionArgs=args,
set_ids=item['ids'],
bulk_add=True))
tools.addMenuItems(syshandle, item_list, len(item_list))
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'])
def getSources(self, args):
try:
# Extract arguments from url
self.args = json.loads(tools.unquote(args))
tools.log('Starting Scraping', 'debug')
if 'showInfo' in self.args:
background = self.args['showInfo']['art'].get('fanart', '')
self.trakt_id = self.args['showInfo']['ids']['trakt']
else:
self.trakt_id = self.args['ids']['trakt']
background = self.args['art'].get('fanart')
self.setText(tools.lang(32081).encode('utf-8'))
self.setBackground(background)
try:
self.getLocalTorrentResults()
except:
pass
self.updateProgress()
if not self.prem_terminate():
self.setText(tools.lang(32082).encode('utf-8'))
self.initProviders()
# Load threads for all sources
for i in self.torrentProviders:
self.torrent_threads.append(
threading.Thread(target=self.getTorrent,
args=(self.args, i)))
for i in self.hosterProviders:
self.hoster_threads.append(
threading.Thread(target=self.getHosters,
args=(self.args, i)))
# Shuffle and start scraping threads
random.shuffle(self.torrent_threads)
random.shuffle(self.hoster_threads)
for i in self.torrent_threads:
i.start()
time.sleep(2)
for i in self.hoster_threads:
i.start()
self.setText(tools.lang(32083).encode('utf-8'))
# Keep alive for gui display and threading
timeout = int(tools.getSetting('general.timeout'))
tools.log('Entering Keep Alive', 'info')
runtime = 0
while self.progress < 100:
tools.log('Remainin Providers %s' %
self.remainingProviders)
if self.prem_terminate() is True or len(
self.remainingProviders) == 0:
if runtime > 5:
break
if self.canceled:
break
self.updateProgress()
# tools.progressDialog.update(progressPercent, line1, line2, line3)
try:
self.setProgress()
self.setText("4K: %s | 1080: %s | 720: %s | SD: %s" % (
tools.colorString(self.torrents_qual_len[0] +
self.hosters_qual_len[0]),
tools.colorString(self.torrents_qual_len[1] +
self.hosters_qual_len[1]),
tools.colorString(self.torrents_qual_len[2] +
self.hosters_qual_len[2]),
tools.colorString(self.torrents_qual_len[3] +
self.hosters_qual_len[3]),
))
self.setText2(
"Torrents: %s | Cached: %s | Hosters: %s" %
(tools.colorString(len(self.allTorrents)),
tools.colorString(len(self.torrentCacheSources)),
tools.colorString(len(self.hosterSources))))
self.setText3(
"Remaining Sources: %s" %
tools.colorString(len(self.remainingProviders)))
except:
import traceback
traceback.print_exc()
# Update Progress
time.sleep(1)
runtime += 1
self.progress = int(100 -
float(1 - (runtime / float(timeout))) *
100)
tools.log('Exited Keep Alive', 'info')
self.debridHosterDuplicates()
##### DUPLICATE REMOVAL #####
# Remove Duplicate Torrent Sources
post_dup = []
check_list = []
for i in self.torrentCacheSources:
if not [i['hash'].lower(), i['debrid_provider']] in check_list:
post_dup.append(i)
check_list.append(
[i['hash'].lower(), i['debrid_provider']])
else:
self.duplicates_amount += 1
self.torrentCacheSources = post_dup
# Remove Duplicate Hoster Sources
post_dup = []
check_list = []
debrid_hosts = copy.deepcopy(self.hosterSources)
debrid_hosts = [i for i in debrid_hosts if 'debrid_provider' in i]
non_debrid = copy.deepcopy(self.hosterSources)
non_debrid = [i for i in non_debrid if 'debrid_provider' not in i]
for i in debrid_hosts:
if not [str(i['url']).lower(), i['debrid_provider']
] in check_list:
post_dup.append(i)
check_list.append(
[str(i['url']).lower(), i['debrid_provider']])
else:
self.duplicates_amount += 1
check_list = []
for i in non_debrid:
if not str(i['url']).lower() in check_list:
post_dup.append(i)
check_list.append(str(i['url']).lower())
else:
self.duplicates_amount += 1
self.hosterSources = post_dup
if not self.silent:
if self.duplicates_amount > 0:
try:
tools.showDialog.notification(
tools.addonName,
'%s ' % str(self.duplicates_amount +
tools.lang(32084).encode('utf-8')),
sound=False)
except:
pass
self.build_cache_assist(self.args)
# Returns empty list if no sources are found, otherwise sort sources
if len(self.torrentCacheSources) + len(self.hosterSources) == 0:
try:
tools.playList.clear()
tools.closeOkDialog()
except:
pass
if self.silent:
tools.showDialog.notification(
tools.addonName,
tools.lang(32085).encode('utf-8'))
self.return_data = ([], self.args)
self.close()
return
sorted = self.sortSources(self.torrentCacheSources,
self.hosterSources)
self.return_data = [sorted, self.args]
self.close()
return
except:
self.close()
import traceback
traceback.print_exc()
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(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 directToEpisodeBuilder(self, traktList, title_appends=None, 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 = "%s: %sx%s %s" % (
tools.colorString(
args['showInfo']['info']['tvshowtitle']),
str(item['info']['season']).zfill(2),
str(item['info']['episode']).zfill(2),
item['info']['title'].encode('utf-8'))
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, 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 seasonListBuilder(self, traktList, showInfo, smartPlay=False):
self.threadList = []
showInfo['info']['no_seasons'] = len(traktList)
for item in traktList:
# if tools.getSetting('general.metalocation') == '1':
if 1 == 1:
self.threadList.append(
Thread(target=self.tvdbSeasonListWorker,
args=(item, showInfo)))
else:
self.threadList.append(
Thread(target=self.tmdbSeasonListWorker,
args=(item, showInfo)))
self.runThreads()
if smartPlay is False and tools.getSetting('trakt.auth') != '':
try:
traktWatched = trakt.json_response(
'shows/%s/progress/watched' % showInfo['ids']['trakt'])
except:
pass
self.itemList = [x for x in self.itemList if x is not None]
self.itemList = sorted(self.itemList,
key=lambda k: k['info']['sortseason'])
for item in self.itemList:
cm = []
action = ''
if item is None: continue
if smartPlay is False and tools.getSetting('trakt.auth') != '':
try:
for season in traktWatched['seasons']:
if int(item['info']['season']) == int(
season['number']):
if season['completed'] == season['aired']:
item['info']['playcount'] = 1
except:
import traceback
traceback.print_exc()
pass
try:
args = {'showInfo': {}, 'seasonInfo': {}}
action = 'seasonEpisodes'
args['showInfo'] = showInfo
args['seasonInfo']['info'] = item['info']
args['seasonInfo']['art'] = item['art']
args['seasonInfo']['ids'] = item['ids']
name = item['info']['season_title']
args = tools.quote(json.dumps(args, sort_keys=True))
except:
import traceback
traceback.print_exc()
continue
if smartPlay is True:
return 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('no_seasons')
item['info'].pop('season_title')
item['info'].pop('overview')
item['info'].pop('seasonCount')
item['info'].pop('episodeCount')
item['info'].pop('showaliases')
except:
pass
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
cm=cm,
isFolder=True,
isPlayable=False,
actionArgs=args,
set_ids=item['ids'])
def dispatch(params):
from resources.lib.common import tools
from resources.lib.modules import database
tools.SETTINGS_CACHE = {}
try:
url = params.get('url')
action = params.get('action')
page = params.get('page')
actionArgs = params.get('actionArgs')
pack_select = params.get('packSelect')
source_select = params.get('source_select')
seren_reload = True if params.get('seren_reload') == 'true' else False
resume = params.get('resume')
forceresumeoff = True if params.get(
'forceresumeoff') == 'true' else False
forceresumeon = True if params.get(
'forceresumeon') == 'true' else False
smartPlay = True if params.get('smartPlay') == 'true' else False
except:
print('Welcome to console mode')
print('Command Help:')
print(' - Menu Number: opens the relevant menu page')
print(' - shell: opens a interactive python shell within Seren')
print(' - action xxx: run a custom Seren URL argument')
url = ''
action = None
page = ''
actionArgs = ''
pack_select = ''
source_select = ''
seren_reload = ''
resume = None
forceresumeoff = True if params.get(
'forceresumeoff') == 'true' else False
forceresumeon = True if params.get(
'forceresumeon') == 'true' else False
smartPlay = True if params.get('smartPlay') == 'true' else False
tools.log('Seren, Running Path - Action: %s, actionArgs: %s' %
(action, actionArgs))
if action is None:
from resources.lib.gui import homeMenu
homeMenu.Menus().home()
########Begin Soul TV Modifications
########Begin Soul TV Modifications
if action == 'soulmovieHome':
from resources.lib.gui import movieMenus
movieMenus.Menus().discoverSoul()
if action == 'soultvshowHome':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().discoverSoul()
if action == 'moviesLatest':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesLatest()
if action == 'moviesLatestGary':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesLatest()
if action == 'moviesLatest4k':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesLatest4k()
if action == 'moviesRTBestofyear':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesRTBestofyear()
if action == 'moviesLatestReddit':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesLatestReddit()
if action == 'moviesNetflix':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesNetflix()
if action == 'moviesPixelHunter':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesPixelHunter()
if action == 'moviesNeverseen':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesNeverseen()
if action == 'moviesDisneyP':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesDisneyP()
if action == 'moviesAppleP':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesAppleP()
if action == 'showsGary':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsGary()
if action == 'showsNetflix':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsNetflix()
if action == 'showsPixelHunter':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsPixelHunter()
if action == 'showsAmazon':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsAmazon()
if action == 'showsHulu':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsHulu()
if action == 'showsAppleP':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsAppleP()
if action == 'showsDisneyP':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsDisneyP()
if action == 'soulSpotlight':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().soulSpotlight()
if action == 'showssoulSpotlight':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showssoulSpotlight()
if action == 'moviessoulSpotlight':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviessoulSpotlight()
if action == 'showssoulCurated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showssoulCurated()
if action == 'moviessoulCurated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviessoulCurated()
########End Soul TV Modifications
if action == 'smartPlay':
from resources.lib.modules import smartPlay
# if 'resume' not in actionArgs:
# actionArgs = json.loads(actionArgs)
# actionArgs['resume'] = sys.argv[3].split(':')[-1]
# actionArgs = tools.quote(json.dumps(actionArgs, sort_keys=True))
smartPlay.SmartPlay(actionArgs).fill_playlist()
if action == 'playbackResume':
from resources.lib.modules import smartPlay
smart = smartPlay.SmartPlay(actionArgs)
smart.workaround()
if action == 'moviesHome':
from resources.lib.gui import movieMenus
movieMenus.Menus().discoverMovies()
if action == 'moviesPopular':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesPopular(page)
if action == 'moviesTrending':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesTrending(page)
if action == 'moviesPlayed':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesPlayed(page)
if action == 'moviesWatched':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesWatched(page)
if action == 'moviesCollected':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesCollected(page)
if action == 'moviesAnticipated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesAnticipated(page)
if action == 'moviesBoxOffice':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesBoxOffice()
if action == 'moviesUpdated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesUpdated(page)
if action == 'moviesRecommended':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesRecommended()
if action == 'moviesSearch':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearch(actionArgs)
if action == 'moviesSearchResults':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearchResults(actionArgs)
if action == 'moviesSearchHistory':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesSearchHistory()
if action == 'myMovies':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovies()
if action == 'moviesMyCollection':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovieCollection()
if action == 'moviesMyWatchlist':
from resources.lib.gui import movieMenus
movieMenus.Menus().myMovieWatchlist()
if action == 'moviesRelated':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesRelated(actionArgs)
if action == 'colorPicker':
tools.colorPicker()
if action == 'authTrakt':
from resources.lib.indexers import trakt
trakt.TraktAPI().auth()
if action == 'revokeTrakt':
from resources.lib.indexers import trakt
trakt.TraktAPI().revokeAuth()
if action == 'getSources':
try:
item_information = tools.get_item_information(actionArgs)
#
# This tomfoolery here is the new workaround for Seren to skip the building playlist window
if tools.getSetting(
'smartplay.playlistcreate') == 'true' or smartPlay:
if tools.playList.size() > 0:
playlist_uris = [
tools.playList[i].getPath()
for i in range(tools.playList.size())
]
else:
playlist_uris = []
if ('showInfo' in item_information and tools.playList.size() == 0) \
or not any(sys.argv[2] in i for i in playlist_uris):
try:
name = item_information['info']['title']
item = tools.addDirectoryItem(
name,
'getSources',
item_information['info'],
item_information['art'],
item_information['cast'],
isFolder=False,
isPlayable=True,
actionArgs=actionArgs,
bulk_add=True,
set_ids=item_information['ids'])
tools.cancelPlayback()
tools.playList.add(url=sys.argv[0] + sys.argv[2],
listitem=item[1])
tools.player().play(tools.playList)
return
except:
import traceback
traceback.print_exc()
return
bookmark_style = tools.getSetting('general.bookmarkstyle')
if tools.playList.size(
) == 1 and resume is not None and bookmark_style != '2' and not forceresumeoff:
if bookmark_style == '0' and not forceresumeon:
import datetime
selection = tools.showDialog.contextmenu([
'{} {}'.format(
tools.lang(32092),
datetime.timedelta(seconds=int(resume))),
tools.lang(40350)
])
if selection == -1:
tools.cancelPlayback()
sys.exit()
elif selection != 0:
resume = None
else:
resume = None
# Assume if we couldn't get information using the normal method, that it's the legacy method
if item_information is None:
item_information = actionArgs
if not tools.premium_check():
tools.showDialog.ok(tools.addonName, tools.lang(40146),
tools.lang(40147))
return None
if tools.playList.getposition() == 0 and tools.getSetting(
'general.scrapedisplay') == '0':
display_background = True
else:
display_background = False
from resources.lib.modules.skin_manager import SkinManager
if display_background:
from resources.lib.gui.windows.persistent_background import PersistentBackground
background = PersistentBackground(
*SkinManager().confirm_skin_path(
'persistent_background.xml'),
actionArgs=actionArgs)
background.setText(tools.lang(32045))
background.show()
from resources.lib.modules import getSources
uncached_sources, source_results, args = database.get(
getSources.getSourcesHelper,
1,
actionArgs,
seren_reload=seren_reload,
seren_sources=True)
if len(source_results) <= 0:
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
return
if 'showInfo' in item_information:
source_select_style = 'Episodes'
else:
source_select_style = 'Movie'
if tools.getSetting(
'general.playstyle%s' %
source_select_style) == '1' or source_select == 'true':
try:
background.setText(tools.lang(40135))
except:
pass
from resources.lib.modules import sourceSelect
stream_link = sourceSelect.sourceSelect(
uncached_sources, source_results, actionArgs)
if stream_link is None:
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
raise Exception
if not stream_link:
# user has backed out of source select, don't show no playable sources notification
raise Exception
else:
try:
background.setText(tools.lang(32046))
except:
pass
from resources.lib.modules import resolver
resolver_window = resolver.Resolver(
*SkinManager().confirm_skin_path('resolver.xml'),
actionArgs=actionArgs)
stream_link = database.get(resolver_window.doModal,
1,
source_results,
args,
pack_select,
seren_reload=seren_reload)
del resolver_window
if stream_link is None:
tools.closeBusyDialog()
tools.showDialog.notification(tools.addonName,
tools.lang(32047),
time=5000)
raise Exception
tools.showBusyDialog()
try:
background.close()
except:
pass
try:
del background
except:
pass
from resources.lib.modules import player
# if 'resume' not in actionArgs:
# actionArgs = json.loads(actionArgs)
# actionArgs['resume'] = sys.argv[3].split(':')[-1]
# actionArgs = json.dumps(actionArgs, sort_keys=True)
player.serenPlayer().play_source(stream_link,
actionArgs,
resume_time=resume,
params=params)
except:
import traceback
traceback.print_exc()
# Perform cleanup and make sure all open windows close and playlist is cleared
try:
tools.closeBusyDialog()
except:
pass
try:
background.close()
except:
pass
try:
del background
except:
pass
try:
resolver_window.close()
except:
pass
try:
del resolver_window
except:
pass
try:
tools.playList.clear()
except:
pass
try:
tools.closeOkDialog()
except:
pass
try:
tools.cancelPlayback()
except:
pass
if action == 'preScrape':
from resources.lib.modules.skin_manager import SkinManager
try:
item_information = tools.get_item_information(actionArgs)
if 'showInfo' in item_information:
source_select_style = 'Episodes'
else:
source_select_style = 'Movie'
from resources.lib.modules import getSources
uncached_sources, source_results, args = database.get(
getSources.getSourcesHelper,
1,
actionArgs,
seren_reload=seren_reload,
seren_sources=True)
if tools.getSetting('general.playstyle%s' %
source_select_style) == '0':
from resources.lib.modules import resolver
resolver_window = resolver.Resolver(
*SkinManager().confirm_skin_path('resolver.xml'),
actionArgs=actionArgs)
database.get(resolver_window.doModal,
1,
source_results,
args,
pack_select,
seren_reload=seren_reload)
tools.setSetting(id='general.tempSilent', value='false')
except:
tools.setSetting(id='general.tempSilent', value='false')
import traceback
traceback.print_exc()
pass
tools.log('Pre-scraping completed')
if action == 'authRealDebrid':
from resources.lib.debrid import real_debrid
real_debrid.RealDebrid().auth()
if action == 'showsHome':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().discoverShows()
if action == 'myShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShows()
if action == 'showsMyCollection':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShowCollection()
if action == 'showsMyWatchlist':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myShowWatchlist()
if action == 'showsMyProgress':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myProgress()
if action == 'showsMyRecentEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myRecentEpisodes()
if action == 'showsPopular':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsPopular(page)
if action == 'showsRecommended':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsRecommended()
if action == 'showsTrending':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsTrending(page)
if action == 'showsPlayed':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsPlayed(page)
if action == 'showsWatched':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsWatched(page)
if action == 'showsCollected':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsCollected(page)
if action == 'showsAnticipated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsAnticipated(page)
if action == 'showsUpdated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsUpdated(page)
if action == 'showsSearch':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsSearch(actionArgs)
if action == 'showsSearchResults':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsSearchResults(actionArgs)
if action == 'showsSearchHistory':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showSearchHistory()
if action == 'showSeasons':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showSeasons(actionArgs)
if action == 'seasonEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().seasonEpisodes(actionArgs)
if action == 'showsRelated':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsRelated(actionArgs)
if action == 'showYears':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showYears(actionArgs, page)
if action == 'searchMenu':
from resources.lib.gui import homeMenu
homeMenu.Menus().searchMenu()
if action == 'toolsMenu':
from resources.lib.gui import homeMenu
homeMenu.Menus().toolsMenu()
if action == 'clearCache':
from resources.lib.common import tools
tools.clearCache()
if action == 'traktManager':
from resources.lib.indexers import trakt
trakt.TraktAPI().traktManager(actionArgs)
if action == 'onDeckShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().onDeckShows()
if action == 'onDeckMovies':
from resources.lib.gui.movieMenus import Menus
Menus().onDeckMovies()
if action == 'cacheAssist':
from resources.lib.modules import cacheAssist
cacheAssist.CacheAssit(actionArgs)
if action == 'tvGenres':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showGenres()
if action == 'showGenresGet':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showGenreList(actionArgs, page)
if action == 'movieGenres':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieGenres()
if action == 'movieGenresGet':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieGenresList(actionArgs, page)
if action == 'filePicker':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).torrent_file_picker()
if action == 'shufflePlay':
from resources.lib.modules import smartPlay
try:
smart = smartPlay.SmartPlay(actionArgs).shufflePlay()
except:
import traceback
traceback.print_exc()
pass
if action == 'resetSilent':
tools.setSetting('general.tempSilent', 'false')
tools.showDialog.notification('{}: {}'.format(tools.addonName,
tools.lang(40296)),
tools.lang(32048),
time=5000)
if action == 'clearTorrentCache':
from resources.lib.modules import database
database.torrent_cache_clear()
if action == 'openSettings':
tools.execute('Addon.OpenSettings(%s)' % tools.addonInfo('id'))
if action == 'myTraktLists':
from resources.lib.indexers import trakt
trakt.TraktAPI().myTraktLists(actionArgs)
if action == 'traktList':
from resources.lib.indexers import trakt
trakt.TraktAPI().getListItems(actionArgs, page)
if action == 'nonActiveAssistClear':
from resources.lib.gui import debridServices
debridServices.Menus().assist_non_active_clear()
if action == 'debridServices':
from resources.lib.gui import debridServices
debridServices.Menus().home()
if action == 'cacheAssistStatus':
from resources.lib.gui import debridServices
debridServices.Menus().get_assist_torrents()
if action == 'premiumizeTransfers':
from resources.lib.gui import debridServices
debridServices.Menus().list_premiumize_transfers()
if action == 'showsNextUp':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myNextUp()
if action == 'runMaintenance':
from resources.lib.common import maintenance
maintenance.run_maintenance()
if action == 'providerTools':
from resources.lib.gui import homeMenu
homeMenu.Menus().providerMenu()
if action == 'adjustProviders':
tools.log('adjustProviders endpoint has been deprecated')
return
# from resources.lib.modules import customProviders
#
# customProviders.providers().adjust_providers(actionArgs)
if action == 'adjustPackage':
tools.log('adjustPackage endpoint has been deprecated')
return
# DEPRECATED
# from resources.lib.modules import customProviders
#
# customProviders.providers().adjust_providers(actionArgs, package_disable=True)
if action == 'installProviders':
from resources.lib.modules import customProviders
customProviders.providers().install_package(actionArgs)
if action == 'uninstallProviders':
from resources.lib.modules import customProviders
customProviders.providers().uninstall_package()
if action == 'showsNew':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().newShows()
if action == 'realdebridTransfers':
from resources.lib.gui import debridServices
debridServices.Menus().list_RD_transfers()
if action == 'cleanInstall':
from resources.lib.common import maintenance
maintenance.wipe_install()
if action == 'buildPlaylistWorkaround':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).resume_playback()
if action == 'premiumizeCleanup':
from resources.lib.common import maintenance
maintenance.premiumize_transfer_cleanup()
if action == 'test2':
pass
if action == 'manualProviderUpdate':
from resources.lib.modules import customProviders
customProviders.providers().manual_update()
if action == 'clearSearchHistory':
from resources.lib.modules import database
database.clearSearchHistory()
if action == 'externalProviderInstall':
from resources.lib.modules import customProviders
confirmation = tools.showDialog.yesno(tools.addonName,
tools.lang(40117))
if confirmation == 0:
sys.exit()
customProviders.providers().install_package(1, url=url)
if action == 'externalProviderUninstall':
from resources.lib.modules import customProviders
confirmation = tools.showDialog.yesno(tools.addonName,
tools.lang(40119) % url)
if confirmation == 0:
sys.exit()
customProviders.providers().uninstall_package(package=url,
silent=False)
if action == 'showsNetworks':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsNetworks()
if action == 'showsNetworkShows':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsNetworkShows(actionArgs, page)
if action == 'movieYears':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieYears()
if action == 'movieYearsMovies':
from resources.lib.gui import movieMenus
movieMenus.Menus().movieYearsMovies(actionArgs, page)
if action == 'syncTraktActivities':
from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
TraktSyncDatabase().sync_activities()
if action == 'traktSyncTools':
from resources.lib.gui import homeMenu
homeMenu.Menus().traktSyncTools()
if action == 'flushTraktActivities':
from resources.lib.modules import trakt_sync
trakt_sync.TraktSyncDatabase().flush_activities()
if action == 'flushTraktDBMeta':
from resources.lib.modules import trakt_sync
trakt_sync.TraktSyncDatabase().clear_all_meta()
if action == 'myFiles':
from resources.lib.gui import myFiles
myFiles.Menus().home()
if action == 'myFilesFolder':
from resources.lib.gui import myFiles
myFiles.Menus().myFilesFolder(actionArgs)
if action == 'myFilesPlay':
from resources.lib.gui import myFiles
myFiles.Menus().myFilesPlay(actionArgs)
if action == 'forceTraktSync':
from resources.lib.modules import trakt_sync
from resources.lib.modules.trakt_sync.activities import TraktSyncDatabase
trakt_sync.TraktSyncDatabase().flush_activities()
TraktSyncDatabase().sync_activities()
if action == 'rebuildTraktDatabase':
from resources.lib.modules.trakt_sync import TraktSyncDatabase
TraktSyncDatabase().re_build_database()
if action == 'myUpcomingEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myUpcomingEpisodes()
if action == 'myWatchedEpisodes':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().myWatchedEpisodes(page)
if action == 'myWatchedMovies':
from resources.lib.gui import movieMenus
movieMenus.Menus().myWatchedMovies(page)
if action == 'showsByActor':
from resources.lib.gui import tvshowMenus
tvshowMenus.Menus().showsByActor(actionArgs)
if action == 'movieByActor':
from resources.lib.gui import movieMenus
movieMenus.Menus().moviesByActor(actionArgs)
if action == 'playFromRandomPoint':
from resources.lib.modules import smartPlay
smartPlay.SmartPlay(actionArgs).play_from_random_point()
if action == 'refreshProviders':
from resources.lib.modules.customProviders import providers
providers().update_known_providers()
if action == 'installSkin':
from resources.lib.modules.skin_manager import SkinManager
SkinManager().install_skin()
if action == 'uninstallSkin':
from resources.lib.modules.skin_manager import SkinManager
SkinManager().uninstall_skin()
if action == 'switchSkin':
from resources.lib.modules.skin_manager import SkinManager
SkinManager().switch_skin()
if action == 'manageProviders':
tools.showBusyDialog()
from resources.lib.gui.windows.custom_providers import CustomProviders
from resources.lib.modules.skin_manager import SkinManager
CustomProviders(*SkinManager().confirm_skin_path(
'custom_providers.xml')).doModal()
if action == 'flatEpisodes':
from resources.lib.gui.tvshowMenus import Menus
Menus().flat_episode_list(actionArgs)
if action == 'runPlayerDialogs':
from resources.lib.modules.player import PlayerDialogs
try:
PlayerDialogs().display_dialog()
except:
import traceback
traceback.print_exc()
if action == 'authAllDebrid':
from resources.lib.debrid.all_debrid import AllDebrid
AllDebrid().auth()
if action == 'checkSkinUpdates':
from resources.lib.modules.skin_manager import SkinManager
SkinManager().check_for_updates()
if action == 'authPremiumize':
from resources.lib.debrid.premiumize import Premiumize
Premiumize().auth()
def get(self, url, **params):
if not tools.getSetting('alldebrid.enabled') == 'true':
return
params.update({'agent': self.agent_identifier})
return self.session.get(tools.urljoin(self.base_url, url),
params=params)
def __init__(self):
self.itemList = []
self.threadList = []
self.viewType = tools.getSetting('movie.view')
def build_cache_assist(self, args):
if tools.getSetting('general.autocache') == 'false':
return
if len(self.allTorrents) == 0:
return
if len(self.torrentCacheSources) > 0:
return
build_list = []
if tools.getSetting('general.cacheAssistMode') == "0":
quality_list = ['1080p', '720p', 'SD']
for quality in quality_list:
if len(build_list) > 0: break
if len([
i for i in self.torrentCacheSources
if i['quality'] == quality
]) == 0:
quality_filter = [
i for i in self.allTorrents if i['quality'] == quality
]
if len(quality_filter) > 0:
packtype_filter = [
i for i in quality_filter if i['package'] == 'show'
or i['package'] == 'season'
]
sorted_list = sorted(packtype_filter,
key=lambda k: k['seeds'],
reverse=True)
if len(sorted_list) > 0:
build_list.append(sorted_list[0])
break
else:
package_type_list = [
i for i in quality_filter
if i['package'] == 'single'
]
sorted_list = sorted(package_type_list,
key=lambda k: k['seeds'],
reverse=True)
if sorted_list > 0:
build_list.append(sorted_list[0])
else:
if self.silent is True:
return
yesno = tools.showDialog.yesno(
'%s - Cache Assist' % tools.addonName,
tools.lang(32086).encode('utf-8'))
if yesno == 0:
return
display_list = [
'%sS | %s | %s | %s' %
(i['seeds'], tools.color_quality(
i['quality']), tools.source_size_display(
i['size']), tools.colorString(i['release_title']))
for i in self.allTorrents
]
selection = tools.showDialog.select(
'%s - ' % tools.addonName + tools.lang(32087).encode('utf-8'),
display_list)
if selection == -1:
return
build_list.append(self.allTorrents[selection])
if len(build_list) > 0:
actionArgs = {'torrent_list': build_list, 'args': args}
actionArgs = tools.quote(json.dumps(actionArgs))
tools.execute('RunPlugin(%s?action=cacheAssist&actionArgs=%s)' %
(sysaddon, actionArgs))
return
def __init__(self):
self.agent_identifier = tools.addonName
self.token = tools.getSetting('alldebrid.token')
self.base_url = 'https://api.alldebrid.com/'
def sortSources(self, torrent_list, hoster_list):
sort_method = int(tools.getSetting('general.sortsources'))
sortedList = []
resolutions = self.resolutionList()
resolutions.reverse()
if tools.getSetting('general.sizesort') == 'true':
torrent_list = sorted(torrent_list,
key=lambda k: k['size'],
reverse=True)
else:
random.shuffle(torrent_list)
if tools.getSetting('general.disable3d') == 'true':
torrent_list = [i for i in torrent_list if '3D' not in i['info']]
hoster_list = [i for i in hoster_list if '3D' not in i['info']]
if tools.getSetting('general.disablelowQuality') == 'true':
torrent_list = [i for i in torrent_list if 'CAM' not in i['info']]
hoster_list = [i for i in hoster_list if 'CAM' not in i['info']]
if tools.getSetting('general.enablesizelimit') == 'true':
size_limit = int(tools.getSetting('general.sizelimit')) * 1024
torrent_list = [
i for i in torrent_list if i.get('size', 0) < size_limit
]
if tools.getSetting('general.265sort') == 'true':
torrent_list = [i for i in torrent_list if 'x265' in i['info']] + \
[i for i in torrent_list if 'x265' not in i['info']]
hoster_list = [i for i in hoster_list if 'x265' in i['info']] + \
[i for i in hoster_list if 'x265' not in i['info']]
if tools.getSetting('general.lowQualitysort') == 'true':
torrent_list = [i for i in torrent_list if 'CAM' not in i['info']] + \
[i for i in torrent_list if 'CAM' in i['info']]
hoster_list = [i for i in hoster_list if 'CAM' not in i['info']] + \
[i for i in hoster_list if 'CAM' in i['info']]
random.shuffle(hoster_list)
debrid_priorities = self.debrid_priority()
for resolution in resolutions:
if sort_method == 0 or sort_method == 2:
for debrid in debrid_priorities:
for torrent in torrent_list:
if debrid['slug'] == torrent['debrid_provider']:
if torrent['quality'] == resolution:
sortedList.append(torrent)
if sort_method == 1 or sort_method == 2:
for debrid in debrid_priorities:
for file in hoster_list:
if 'debrid_provider' in file:
if file['debrid_provider'] == debrid['slug']:
if file['quality'] == resolution:
sortedList.append(file)
for file in hoster_list:
if 'debrid_provider' not in file:
if file['quality'] == resolution:
sortedList.append(file)
if sort_method == 1:
for resolution in resolutions:
for debrid in debrid_priorities:
for torrent in torrent_list:
if torrent['debrid_provider'] == debrid['slug']:
if torrent['quality'] == resolution:
sortedList.append(torrent)
if sort_method == 0:
for resolution in resolutions:
for debrid in debrid_priorities:
for file in hoster_list:
if 'debrid_provider' in file:
if file['debrid_provider'] == debrid['slug']:
if file['quality'] == resolution:
sortedList.append(file)
for file in hoster_list:
try:
if 'debrid_provider' not in file and file[
'direct'] is True:
if file['quality'] == resolution:
sortedList.append(file)
except:
continue
if tools.getSetting('general.disable265') == 'true':
sortedList = [i for i in sortedList if 'x265' not in i['info']]
return sortedList
def __init__(self):
self.itemList = []
self.threadList = []
self.direct_episode_threads = []
self.title_appends = tools.getSetting('general.appendtitles')
self.task_queue = Queue(40)
def resolve_magnet(self, magnet, args, torrent, pack_select=False):
try:
if torrent['package'] == 'single' or 'showInfo' not in args:
return self._single_magnet_resolve(torrent)
hash = torrent['hash']
hashCheck = self.checkHash(hash)
cached_torrent = self.addMagnet(torrent['magnet'])
for storage_variant in hashCheck[hash]['rd']:
valid_storage = self.is_streamable_storage_type(
storage_variant)
if not valid_storage:
tools.log(
'Storage Variant of file is not valid, RD will not provide a playable link',
'error')
continue
file_check = source_utils.get_best_match(
'filename', storage_variant.values(), args)
if not file_check:
tools.log('Failed to find the file within the pack at RD',
'error')
continue
key_list = storage_variant.keys()
if len(key_list) == 0:
tools.log(
'Received no keys from storage varaint (RD), skipping',
'error')
self.deleteTorrent(cached_torrent['id'])
return None
key_list = ','.join(key_list)
self.torrentSelect(cached_torrent['id'], key_list)
link = self.torrentInfo(cached_torrent['id'])
selected_files = [(idx, i) for idx, i in enumerate(
[i for i in link['files'] if i['selected'] == 1])]
best_match = source_utils.get_best_match(
'path', [i[1] for i in selected_files], args)
if not best_match:
tools.log('Failed to find the file within the pack at RD',
'error')
continue
file_index = [
i[0] for i in selected_files
if i[1]['path'] == best_match['path']
][0]
link = link['links'][file_index]
link = self.resolve_hoster(link)
if link.endswith('rar'):
link = None
if tools.getSetting('rd.autodelete') == 'true':
self.deleteTorrent(cached_torrent['id'])
return link
except:
import traceback
traceback.print_exc()
self.deleteTorrent(cached_torrent['id'])
return None
def episodeListBuilder(self,
show_id,
season_number,
smartPlay=False,
hide_unaired=False):
try:
item_list = []
self.itemList = TraktSyncDatabase().get_season_episodes(
show_id, season_number)
self.itemList = [
x for x in self.itemList if x is not None and 'info' in x
]
if len(self.itemList) == 0:
tools.log('We received no titles to build a list', 'error')
return
try:
self.itemList = sorted(self.itemList,
key=lambda k: k['info']['episode'])
except:
pass
for item in self.itemList:
cm = []
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'] = item['showInfo']
args['episodeInfo']['info'] = item['info']
args['episodeInfo']['art'] = item['art']
args['episodeInfo']['ids'] = item['ids']
name = item['info']['title']
if not self.is_aired(item['info']):
if tools.getSetting('general.hideUnAired'
) == 'true' or hide_unaired:
continue
else:
name = tools.colorString(name, 'red')
name = tools.italic_string(name)
item['info']['title'] = name
item['info'] = tools.clean_air_dates(item['info'])
args = tools.quote(json.dumps(args, sort_keys=True))
except:
import traceback
traceback.print_exc()
continue
cm.append((tools.lang(
33022
), 'PlayMedia(%s?action=getSources&seren_reload=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(
32066
), '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),
'XBMC.RunPlugin(%s?action=filePicker&actionArgs=%s)' %
(sysaddon, args)))
item_list.append(
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
isFolder=False,
isPlayable=playable,
actionArgs=args,
bulk_add=True,
set_ids=item['ids'],
cm=cm))
if smartPlay is True:
return item_list
else:
tools.addMenuItems(syshandle, item_list, len(item_list))
except:
import traceback
traceback.print_exc()
def trakt_integration(self):
if tools.getSetting('trakt.auth') == '':
return False
else:
if tools.getSetting('trakt.scrobbling') == 'true':
return True
def showListBuilder(self, trakt_list, forceResume=False, info_only=False):
try:
if len(trakt_list) == 0:
tools.log('We received no titles to build a list', 'error')
return
except:
import traceback
traceback.print_exc()
return
if 'show' in trakt_list[0]:
trakt_list = [i['show'] for i in trakt_list]
show_ids = [i['ids']['trakt'] for i in trakt_list]
self.itemList = TraktSyncDatabase().get_show_list(show_ids)
self.itemList = [
x for x in self.itemList if x is not None and 'info' in x
]
self.itemList = tools.sort_list_items(self.itemList, trakt_list)
item_list = []
for item in self.itemList:
try:
args = {}
cm = []
# Add Arguments to pass with items
args['ids'] = item['ids']
args['info'] = item['info']
args['art'] = item['art']
name = tools.display_string(item['info']['tvshowtitle'])
args = tools.quote(json.dumps(args, sort_keys=True))
if info_only == True:
return args
if not self.is_aired(item['info']):
if tools.getSetting('general.hideUnAired') == 'true':
continue
name = tools.colorString(name, 'red')
name = tools.italic_string(name)
item['info'] = tools.clean_air_dates(item['info'])
if 'setCast' in item:
set_cast = item['setCast']
else:
set_cast = False
if tools.getSetting('smartplay.clickresume'
) == 'true' or forceResume is True:
action = 'smartPlay'
else:
action = 'showSeasons'
# Context Menu Items
cm.append(
(tools.lang(32070),
'XBMC.PlayMedia(%s?action=shufflePlay&actionArgs=%s)' %
(sysaddon, args)))
cm.append(
(tools.lang(32020),
'Container.Update(%s?action=showsRelated&actionArgs=%s)' %
(sysaddon, item['ids']['trakt'])))
cm.append((tools.lang(
32069
), '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'])))))
cm.append((tools.lang(
40153
), 'XBMC.PlayMedia(%s?aciton=playFromRandomPoint&actionArgs=%s'
% (sysaddon, args)))
if tools.context_addon():
cm = []
except:
import traceback
traceback.print_exc()
continue
item_list.append(
tools.addDirectoryItem(name,
action,
item['info'],
item['art'],
cm=cm,
isFolder=True,
isPlayable=False,
actionArgs=args,
bulk_add=True,
set_cast=set_cast,
set_ids=item['ids']))
tools.addMenuItems(syshandle, item_list, len(item_list))
def next_info(self):
current_info = self.args
current_episode = {}
current_episode["episodeid"] = current_info['episodeInfo']['ids'][
'trakt']
current_episode["tvshowid"] = current_info['showInfo']['info'][
'imdbnumber']
current_episode["title"] = current_info['episodeInfo']['info']['title']
current_episode["art"] = {}
current_episode["art"]["tvshow.poster"] = current_info['episodeInfo'][
'art']['poster']
current_episode["art"]["thumb"] = current_info['episodeInfo']['art'][
'thumb']
current_episode["art"]["tvshow.fanart"] = current_info['episodeInfo'][
'art']['fanart']
current_episode["art"]["tvshow.landscape"] = current_info[
'episodeInfo']['art']['fanart']
current_episode["art"]["tvshow.clearart"] = ''
current_episode["art"]["tvshow.clearlogo"] = ''
current_episode["plot"] = current_info['episodeInfo']['info']['plot']
current_episode["showtitle"] = current_info['showInfo']['info'][
'tvshowtitle']
current_episode["playcount"] = 0
current_episode["season"] = current_info['episodeInfo']['info'][
'season']
current_episode["episode"] = current_info['episodeInfo']['info'][
'episode']
current_episode["rating"] = current_info['episodeInfo']['info'][
'rating']
current_episode["firstaired"] = current_info['episodeInfo']['info'][
'premiered']
current_position = tools.playList.getposition()
url = tools.playList[current_position + 1].getPath()
params = dict(tools.parse_qsl(url.replace('?', '')))
next_info = json.loads(params.get('actionArgs'))
next_episode = {}
next_episode["episodeid"] = next_info['episodeInfo']['ids']['trakt']
next_episode["tvshowid"] = next_info['showInfo']['info']['imdbnumber']
next_episode["title"] = next_info['episodeInfo']['info']['title']
next_episode["art"] = {}
next_episode["art"]["tvshow.poster"] = next_info['episodeInfo']['art'][
'poster']
next_episode["art"]["thumb"] = next_info['episodeInfo']['art']['thumb']
next_episode["art"]["tvshow.fanart"] = next_info['episodeInfo']['art'][
'fanart']
next_episode["art"]["tvshow.landscape"] = next_info['episodeInfo'][
'art']['fanart']
next_episode["art"]["tvshow.clearart"] = ''
next_episode["art"]["tvshow.clearlogo"] = ''
next_episode["plot"] = next_info['episodeInfo']['info']['plot']
next_episode["showtitle"] = next_info['showInfo']['info'][
'tvshowtitle']
next_episode["playcount"] = 0
next_episode["season"] = next_info['episodeInfo']['info']['season']
next_episode["episode"] = next_info['episodeInfo']['info']['episode']
next_episode["rating"] = next_info['episodeInfo']['info']['rating']
next_episode["firstaired"] = next_info['episodeInfo']['info'][
'premiered']
play_info = {}
play_info["item_id"] = current_info['episodeInfo']['ids']['trakt']
next_info = {
"current_episode": current_episode,
"next_episode": next_episode,
"play_info": play_info,
"notification_time": int(tools.getSetting('smartplay.upnexttime'))
}
return next_info
def resolve(self, sources, args, pack_select=False):
try:
if 'showInfo' in args:
background = args['showInfo']['art']['fanart']
else:
background = args['fanart']
self.setText("Begining Link Resolver")
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 = tools.lang(32036) + "%s - %s" % (tools.colorString(
i['release_title']), loop_count_string)
line2 = tools.lang(32037) + "%s | Source: %s" % (
tools.colorString(debrid_provider.upper()),
tools.colorString(i['source']))
line3 = tools.lang(32038) + '%s | Info: %s' % (
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()
return
except:
import traceback
traceback.print_exc()
self.close()
return
def commonListBuilder(self, trakt_list, info_return=False):
if len(trakt_list) == 0:
return
if 'movie' in trakt_list[0]:
trakt_list = [i['movie'] for i in trakt_list]
self.itemList = TraktSyncDatabase().get_movie_list(trakt_list)
self.itemList = [
x for x in self.itemList if x is not None and 'info' in x
]
self.itemList = tools.sort_list_items(self.itemList, trakt_list)
list_items = []
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']
args['imdb'] = item['info']['imdbnumber']
args['tagline'] = item['info']['tagline']
args['plot'] = item['info']['plot']
args['rating'] = item['info']['rating']
args['duration'] = item['info']['duration']
name = tools.display_string(item['info']['title'])
if not self.is_aired(item['info']):
if tools.getSetting('general.hideUnAired') == 'true':
continue
name = tools.colorString(name, 'red')
name = tools.italic_string(name)
args = tools.quote(json.dumps(args))
# Begin Building Context Menu Items
cm = []
cm.append((
tools.lang(32020),
'Container.Update(%s?action=moviesRelated&actionArgs=%s)' %
(sysaddon, item['ids']['trakt'])))
cm.append((tools.lang(
32066
), 'PlayMedia(%s?action=getSources&source_select=true&actionArgs=%s)'
% (sysaddon, args)))
cm.append((tools.lang(
33022
), '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:
import traceback
traceback.print_exc()
continue
if item is None:
continue
item['info']['title'] = item['info']['originaltitle'] = name
list_items.append(
tools.addDirectoryItem(name,
'getSources',
item['info'],
item['art'],
cm=cm,
isFolder=False,
isPlayable=True,
actionArgs=args,
set_ids=item['ids'],
bulk_add=True))
if info_return:
return list_items
tools.addMenuItems(syshandle, list_items, len(list_items))
