def choose_quality_play_video(self):
helper.start('choose_quality_play_video')
from resources.lib.players.qualityplayer import QualityPlayer
qp = QualityPlayer()
qp.determine_quality()
qp.play()
helper.end('choose_quality_play_video')
def parse(self):
helper.start('EpisodeList.parse')
if self.soup == None:
return
servers = self.soup.find_all('div',
class_='widget servers') #server row')
#server_names = map(lambda x: x.label.string, servers)
links_active = servers[0].find_all('div', class_='server active')
links_hidden = servers[0].find_all('div', class_='server hidden')
links1 = links_active[0].find_all('a')
links2 = links_hidden[-1].find_all('a') #servers[-2].find_all('a')
counter1 = len(links1)
counter2 = len(links2)
if (counter1 > counter2):
links = links1
#helper.show_error_dialog(['',str(counter1)])
else:
links = links2
#helper.show_error_dialog(['',str(links2)])
for link in links:
link['href'] = '%s!!!!%s' % (link['href'].split('/')[-2],
link['data-base'])
#helper.show_error_dialog(['',str(link)])
#links2 = servers[-1].find_all('a')
#for link in links2:
# link['href'] = link['href'].split('/')[-2] + '!!!!' + link['data-base']
self.links = links
self._parse_show_metadata()
self.related_links, self.related_data_tips, self.related_media_type_list = self._parse_links_from_grid(
)
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 parse(self):
if self.soup == None:
return
helper.start('TrendingList.parse')
attrs = {'data-name': 'trending'}
self.links, self.data_tips, self.media_type_list = self._parse_links_from_grid(
attrs)
helper.end('TrendingList.parse')
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 parse(self):
if self.soup == None:
return
helper.start('MediaList.parse')
timestamper = t_s.TimeStamper('MediaList.parse')
self.links, self.data_tips, self.media_type_list = self._parse_links_from_grid()
helper.log_debug('# of links found with class=name: %d' % len(self.links))
self._find_next_page_link()
helper.end('MediaList.parse')
timestamper.stamp_and_dump()
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 search(self):
helper.start('search')
search_string = helper.get_user_input('Search for show title')
if search_string:
args.value = '/search?keyword=%s' % (search_string)
self.show_media_list()
#import urllib
#url = '%s/search?keyword=%s' % (helper.domain_url(), urllib.quote_plus(search_string))
#helper.log_debug('Searching for show %s using url %s' % (search_string, url))
#plugin_url = helper.build_plugin_url({'action':'mediaList', 'value':url})
#helper.update_page(plugin_url)
helper.end('search')
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 add_directories(self, src):
helper.start('LocalList.add_directories')
helper.set_content('addons')
for (name, query) in src:
icon = query.get('icon', '')
fanart = query.get('fanart', '')
helper.add_directory(query,
infolabels={'title': name},
img=icon,
fanart=fanart,
total_items=len(src))
helper.end_of_directory()
helper.end('LocalList.add_directories')
return
def show_last_visited(self):
helper.start('show_last_visited')
from resources.lib.appdata.lastvisited import LastVisited
last_show_queries = LastVisited().get_last_show_visited()
if not last_show_queries:
helper.show_ok_dialog(['Visit a show to populate this directory.'],
'Last Show Visited not set')
else:
args.override(last_show_queries)
if helper.debug_import():
from resources.lib.lists import episodelist, weblist
reload(weblist)
reload(episodelist)
from resources.lib.lists.episodelist import EpisodeList
self.__show_web_list(EpisodeList())
helper.end('show_last_visited')
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 parse(self):
if self.soup == None:
return
helper.start('WatchList.parse with list_type %s' % self.list_type)
watchlist_container = self.soup.find('div', class_='widget watchlist').\
find('div', attrs={'data-name':self.list_type})
if watchlist_container == None:
helper.end('WatchList.parse - watch list is empty')
return
link_containers = watchlist_container.find_all('div', class_='item '+ self.list_type)
self.links = [container.find('a') for container in link_containers] ##find_all for jtitle?
#helper.show_error_dialog(['',str(self.links)])
self.media_type_list = ['preview'] * len(self.links)
self._find_next_page_link()
helper.end('WatchList.parse')
def show_episode_list(self):
helper.start('show_episode_list with media_type %s' % args.media_type)
if args.media_type == 'tvshow':
from resources.lib.lists.episodelist import EpisodeList
l = EpisodeList()
elif args.media_type == 'movie':
from resources.lib.lists.movielist import MovieList
l = MovieList()
elif args.media_type == 'special':
from resources.lib.lists.episodelist import EpisodeList #from resources.lib.lists.specialslist import SpecialsList
l = EpisodeList() #SpecialsList()
else:
# media_type == 'preview', which means we don't know media type
from resources.lib.lists.episodelist import EpisodeList
l = EpisodeList()
self.__show_web_list(l)
from resources.lib.appdata.lastvisited import LastVisited
LastVisited().update_last_show_visited()
helper.end('show_episode_list')
def add_items(self, title_prefix=None):
helper.start('MediaList.add_items')
timestamper = t_s.TimeStamper('MediaList.add_items')
end_dir = (title_prefix == None)
title_prefix = title_prefix if title_prefix else ''
if end_dir:
helper.set_content('tvshows')
mlinks = self.links[:-1] if self.has_next_page else self.links
#helper.show_error_dialog(['',str(self.links)])
# Grabbing metadata is a huge bottleneck, so grabbing it in parallel speeds up things
self.links_with_metadata = [None] * len(mlinks)
if helper.debug_metadata_threads():
map(lambda x: self.worker(x), enumerate(mlinks))#mc_links)
else:
#pool = threadpool.ThreadPool(4)
#pool.map(self.worker, enumerate(mlinks))
#pool.wait_completion()
#helper.show_error_dialog(['',str(mlinks[0])])
#helper.show_error_dialog(['',str(self.media_type_list)])
pool = ThreadPool(8) # Sets the pool size to 4
pool.map(self.worker, enumerate(mlinks))
pool.close()
pool.join()
timestamper.stamp('Grabbing metadata with threads')
#helper.show_error_dialog(['',str(self.links_with_metadata)])
try:
for (name, url, metadata, media_type) in self.links_with_metadata:
icon, fanart = self._get_art_from_metadata(metadata)
query = self._construct_query(url, 'episodeList', metadata, name, media_type)
contextmenu_items = self._get_contextmenu_items(url, name, metadata, media_type)
metadata['title'] = title_prefix + name # adjust title for sub and dub
helper.add_directory(query, metadata, img=icon, fanart=fanart, contextmenu_items=contextmenu_items, total_items=len(mlinks))
except: pass
self._add_next_page_link()
if end_dir:
helper.end_of_directory()
timestamper.stamp_and_dump('Adding all items')
helper.end('MediaList.add_items')
def add_items(self):
helper.start('MovieList.add_items')
helper.set_content('movies')
for link in self.links:
num = link.string.strip()
url = link['href']
# for now, assume media_type is always movie; ignore self.mismatch
metadata = self.get_metadata(args.base_title)
query = self._construct_query(url, 'qualityPlayer', metadata)
#if helper.get_setting('enable-metadata') == 'true':
# metadata['title'] = '%s - %s' % (name, metadata['title'])
if (query['base_title'] == ''):
query['base_title'] = args.base_title
#helper.show_error_dialog(['',str(query)])
helper.add_video_item(query, metadata, img=args.icon, fanart=args.fanart, contextmenu_items=self._get_contextmenu_items())
self._add_related_links()
helper.end_of_directory()
helper.end('MovieList.add_items')
return
def add_items(self):
helper.start('SpecialsList.add_items')
helper.set_content('episodes')
icon, fanart = self._get_art_for_season0()
for link in self.links:
num = link.string.strip()
url = link['href']
metadata = self.get_metadata(args.base_title + ' - ' + num)
query = self._construct_query(url, 'qualityPlayer', metadata)
helper.add_directory(
query,
metadata,
img=args.icon,
fanart=args.fanart,
contextmenu_items=self._get_contextmenu_items())
self._add_related_links()
helper.end_of_directory()
helper.end('SpecialsList.add_items')
return
def show_upcoming_list(self):
helper.start('show_upcoming_list')
from resources.lib.lists.upcominglist import UpcomingList
self.__show_web_list(UpcomingList())
helper.end('show_upcoming_list')
def find_metadata(self):
helper.start('find_metadata')
from resources.lib.metadata import metadatafinder
finder = metadatafinder.MetadataFinder()
finder.search_and_update()
helper.end('find_metadata')
def clear_metadata(self):
helper.start('clear_metadata')
from resources.lib.metadata import metadatahandler
finder1 = metadatahandler.meta
finder1.update_meta_to_nothing(args.media_type, args.base_title)
helper.end('clear_metadata')
def main_menu(self):
helper.start('main_menu')
from resources.lib.lists.locallist import LocalList
LocalList().add_directories(self.__get_main_menu_src())
helper.end('main_menu')
def show_local_list(self):
helper.start('show_local_list')
from resources.lib.lists.locallist import LocalList
LocalList().add_directories(constants.ui_table[args.value])
helper.end('show_local_list')
def show_trending_list(self):
helper.start('show_trending_list')
from resources.lib.lists.trendinglist import TrendingList
self.__show_web_list(TrendingList())
helper.end('show_trending_list')
