def log_in_saved(self):
username = helper.get_setting('username')
password = helper.get_setting('password')
helper.show_busy_notification()
logged_in = self.__login(username, password)
msg = '%s into %s' % (('Successfully logged'
if logged_in else 'Failed to log'), username)
helper.close_busy_notification()
helper.show_small_popup(msg=msg)
def show_media_list(self):
helper.start('show_media_list')
if helper.get_setting(
'preset-sorting'
) != 'Individually select' and 'page=' not in args.value and 'sort=' not in args.value:
args.value += constants.sort_types[helper.get_setting(
'preset-sorting')]
from resources.lib.lists.medialist import MediaList
self.__show_web_list(MediaList())
helper.end('show_media_list')
def get_metadata(self, name, media_type):
if helper.get_setting('enable-metadata') == 'false' or name == 'Next':
return {}, ''
helper.start('MediaList.get_metadata - name: %s, media_type: %s' % (name, media_type))
name_for_movie_search = self.clean_name(name)
name_for_tv_search = self.clean_tv_show_name(name_for_movie_search)
metadata = {}
if media_type == 'tvshow' or media_type == 'special' or media_type == 'preview':
metadata = self.meta.get_meta('tvshow', name_for_tv_search)
if metadata['tvdb_id'] == '':
# If tvshow search failed, and if there was a year in the name, try tv without it
import re
if re.search('( \([12][0-9]{3}\))$', name_for_tv_search) != None:
metadata = self.meta.get_meta('tvshow', name_for_tv_search[:-7], update=True)
if metadata['imdb_id'] != '':
metadata = self.meta.update_meta('tvshow', name_for_tv_search, imdb_id='', new_imdb_id=metadata['imdb_id'])
if metadata['tvdb_id'] != '' and media_type == 'preview':
media_type = 'tvshow'
helper.log_debug('Metadata for show %s: %s' % (name_for_tv_search, metadata))
if media_type == 'movie' or media_type == 'preview':
metadata = self.meta.get_meta('movie', name_for_movie_search)
if metadata['tmdb_id'] != '' and media_type == 'preview':
media_type = 'preview'
helper.log_debug('Metadata for movie %s: %s' % (name_for_movie_search, metadata))
helper.end('MediaList.get_metadata')
return metadata, media_type
def __init__(self):
watch_list_c = constants.watch_list
if ('/user/watchlist') in args.value:
watch_list_c = args.value
#helper.show_error_dialog(['',watch_list_c])
MediaList.__init__(self, watch_list_c)
list_type_values = {}
for (title, query) in constants.submenu_watchlist:
list_type_values[title] = query['value']
# If preset_list_type is Select, then we'll default to what the user selected (args.value)
preset_list_type = helper.get_setting('watch-list-type')
self.list_type = list_type_values.get(preset_list_type, args.value)
if ('folder=planned') in args.value:
self.list_type = 'planned'
if ('folder=all') in args.value:
self.list_type = 'all'
if ('folder=on-hold') in args.value:
self.list_type = 'onhold'
if ('folder=completed') in args.value:
self.list_type = 'watched'
if ('folder=watching') in args.value:
self.list_type = 'watching'
if ('folder=dropped') in args.value:
self.list_type = 'dropped'
def log_in_or_out(self):
if self.is_logged_in():
proceed = helper.show_yes_no_dialog(
'Are you sure you want to log out of your account?')
if proceed:
username = helper.get_setting('username')
self.__logout()
helper.show_small_popup(msg=('Successfully logged out of %s' %
username))
else:
username = helper.get_user_input('Please enter your username')
if username == None:
return
password = helper.get_user_input('Please enter your password',
hidden=True)
if password == None:
return
helper.show_busy_notification()
logged_in = self.__login(username, password)
msg = '%s into %s' % (('Successfully logged' if logged_in else
'Failed to log'), username)
helper.close_busy_notification()
helper.show_small_popup(msg=msg)
def _get_contextmenu_items(self, url, name, metadata, media_type):
contextmenu_items = [('Show information', 'XBMC.Action(Info)')]
# Queueing shows with related links on means that Kodi will try to queue those related
# link folders and fail, and will continue to do so in an infinite loop
if helper.get_setting('related-links') == 'false':
contextmenu_items.append(('Queue item', 'XBMC.Action(Queue)'))
show_queue_query = self._construct_query('', 'showqueue')
show_queue_context_item = constants.runplugin % helper.build_plugin_url(show_queue_query)
contextmenu_items.append(('Show queue', show_queue_context_item))
find_metadata_query = self._construct_query(url, 'findmetadata', metadata, name)
find_metadata_context_item = constants.runplugin % helper.build_plugin_url(find_metadata_query)
find_or_fix = ('Find' if self.meta.is_metadata_empty(metadata, media_type) else 'Fix') + ' metadata'
contextmenu_items.append((find_or_fix, find_metadata_context_item))
#clear_metadata_query = self._construct_query(url, 'clearmetadata', metadata, name, media_type )
#cm_item = constants.runplugin % helper.build_plugin_url(clear_metadata_query)
#contextmenu_items.append(('Clear Metadata', cm_item))
id = self._get_bookmark_id(url)
query = self._construct_query(id, 'addBookmark', metadata, name, media_type)
cm_item = constants.runplugin % helper.build_plugin_url(query)
contextmenu_items.append(('Add bookmark', cm_item))
return contextmenu_items
def determine_quality(self):
#helper.start('QualityPlayer.determine_quality')
#helper.show_error_dialog(['',str(args.value)])
servers = self.soup.find('div', class_='widget servers') #server row')
serverinfo = servers.find('span', class_='tabs') #['data-name']
servernames = re.findall(r'data-name="(.*?)">(.*?)<', str(serverinfo))
#helper.show_error_dialog(['',str(servernames[1][0])])
servername_dialog = []
for element in servernames:
servername_dialog.append(
element[1]) #['MyCloud', 'RapidVideo', 'Openload']
self.serveridx = helper.present_selection_dialog(
'Choose the server from the options below', servername_dialog)
if (self.serveridx == 0):
links_active = servers.find('div', class_='server active')
links1 = links_active.find_all('a')
for link in links1:
if (link['data-base'] == self.database):
self.serverlist = link['href']
#helper.show_error_dialog(['',str(self.serverlist)])
else:
links_active = servers.find_all('div', class_='server hidden')
#helper.show_error_dialog(['',str(links_active)])
# if (self.serveridx == 1):
links1 = links_active[self.serveridx - 1].find_all('a')
for link in links1:
if (link['data-base'] == self.database):
self.serverlist = link['href']
#helper.show_error_dialog(['',str(self.serverlist[idx])])
links = {}
if (self.serveridx != -1):
self.serverid = servernames[self.serveridx][0]
links = self.__get_quality_links()
#helper.show_error_dialog(['',str(self.link)])
if (links != {}):
if helper.get_setting('preset-quality') == 'Individually select':
quality_options = [item['label'] for item in links]
idx = helper.present_selection_dialog(
'Choose the quality from the options below',
quality_options)
if idx != -1:
self.link = links[idx]['file']
if ('https://storage.googleapis.com'
and '.mp4' in str(self.link)):
helper.resolve_url(self.link)
self.link = ''
#helper.show_error_dialog(['',str(self.link)])
else:
self.link = self.__get_best_link_for_preset_quality(links)
def _add_related_links(self):
# Add related links using the ML (since they're all just media)
if len(self.related_links) > 0 and helper.get_setting(
'related-links') == 'true':
mlist = medialist.MediaList(None)
mlist.links = self.related_links
mlist.media_type_list = self.related_media_type_list
mlist.data_tips = self.related_data_tips
mlist.add_items(title_prefix='Related: ')
def add_items(self):
helper.start('EpisodeList.add_items')
if self.links == []:
return
half_eps = 0
episodes = []
for link in self.links:
num = link['data-base'] #.string.strip()
url = link['href']
if self.__is_half_episode(num): # 1a and 1b
half_eps += 1
episodes.append((num, url))
self.num_episodes = len(episodes)
helper.log_debug(
'We have effectively %d episodes with %d half episodes' %
(self.num_episodes, half_eps))
all_metadata = self.get_metadata(args.base_title)
helper.log_debug('We have %d metadata entries' % len(all_metadata))
offset = -1
for idx, (name, url) in enumerate(episodes):
if self.__is_half_episode(name):
offset -= 1
metadata = all_metadata[
int(name) +
offset] if int(name) + offset < len(all_metadata) else {
'title': name
}
icon, fanart = self._get_art_from_metadata(metadata)
query = self._construct_query(url,
'qualityPlayer',
metadata,
media_type=self.media_type)
cm_items = self._get_contextmenu_items()
if helper.get_setting('enable-metadata') == 'true':
metadata['title'] = '%s - %s' % (name, metadata['title'])
#helper.show_error_dialog(['',str(query)])
helper.add_video_item(query,
metadata,
img=icon,
fanart=fanart,
contextmenu_items=cm_items)
self._add_related_links()
helper.set_content('episodes')
helper.add_sort_methods(['episode', 'title'])
helper.end_of_directory()
helper.end('EpisodeList.add_items')
return
def get_metadata(self, name):
if (helper.get_setting('enable-metadata') == 'false'
or (args.imdb_id == None and args.tvdb_id == None)):
return []
all_metadata = self.meta.get_episodes_meta(name, args.imdb_id,
args.tvdb_id,
self.num_episodes,
self.first_air_date,
self.season)
return all_metadata
def init():
'''
Responsible for fetching and caching metadata.
'''
user_tmdb_key = helper.get_setting('tmdb-api-key')
meta = None
if user_tmdb_key != '':
meta = AnimeMetaData(tmdb_api_key=user_tmdb_key)
else:
meta = AnimeMetaData()
return meta
def is_logged_in(self):
username = helper.get_setting('username')
if len(username) == 0:
return False
required_cookies = 0
for cookie in self.net._cj:
if helper.domain() not in cookie.domain:
continue
if cookie.name.lower(
) == 'session' or 'remember_web_' in cookie.name.lower():
required_cookies += 1
return (required_cookies == 2)
def show_sort_list(self):
if helper.get_setting('preset-sorting') != 'Individually select':
self.show_media_list()
return
helper.start('show_sort_list')
sort_list = []
for (sort_type, sort_url) in constants.sort_types.iteritems():
d = {'action': 'mediaList'}
d['value'] = args.value + sort_url
sort_list.append((sort_type, d))
from resources.lib.lists.locallist import LocalList
LocalList().add_directories(sort_list)
helper.end('show_sort_list')
def show_watch_list(self):
if not Account().is_logged_in():
Account().log_in_saved()
if Account().is_logged_in():
preset_watchlist_type = helper.get_setting('watch-list-type')
if args.value == 'submenu_watchlist' and preset_watchlist_type == 'Select':
self.show_local_list()
else:
#helper.show_error_dialog(['','Ping'])
from resources.lib.lists.watchlist import WatchList
self.__show_web_list(WatchList())
else:
helper.show_error_dialog([
'Failed to access account watch list. Please login if you have not already.'
])
def _get_art_for_season0(self):
# Mainly for specials; maybe it should be moved there
helper.start('_get_art_for_season0 for name %s and imdb_id %s' %
(args.base_title, args.imdb_id))
if helper.get_setting('enable-metadata') == 'false':
return None, ''
season_covers = self.meta.get_seasons(args.base_title, args.imdb_id,
['0'])
if len(season_covers) > 0:
icon = season_covers[0]['cover_url']
fanart = season_covers[0]['backdrop_url']
else:
icon = args.icon
fanart = args.fanart
return icon, fanart
def __get_best_link_for_preset_quality(self, links):
preset_quality = int(helper.get_setting('preset-quality').strip('p'))
url_to_play = None
for item in links:
quality = item['label']
if preset_quality >= int(quality.strip('p')):
helper.log_debug(
'Found media to play at matching quality: %s' % quality)
url_to_play = item['file']
break
if url_to_play == None:
helper.log_debug(
'No matching quality found; using the lowest available')
url_to_play = links[-1]['file']
return url_to_play
def get_metadata(self, name):
if helper.get_setting('enable-metadata') == 'false':
return {}
# If we have no previous metadata, and this isn't a mismatch, then
# we've already had a legitimate try with no luck.
if not self.mismatch and (args.imdb_id == None and args.tmdb_id == None):
helper.log_debug('Not a mismatch and no previous results for movie')
return {}
imdb_id = args.imdb_id if args.imdb_id and not self.mismatch else ''
tmdb_id = args.tmdb_id if args.tmdb_id and not self.mismatch else ''
should_update = self.mismatch
metadata = self.meta.get_meta('movie', name, imdb_id, tmdb_id, update=should_update)
# Delete mismtached entries from the tv show cache, since they're not tv shows
if self.mismatch:
self.meta.update_meta_to_nothing('tvshow', name)
helper.log_debug('Movie mismatch - new meta: %s' % str(self.meta))
return metadata
