def build_in_progress_episode(): from modules.indicators_bookmarks import get_watched_info_tv def process_eps(item): listitem = build_episode( { "season": int(item[1]), "episode": int(item[2]), "meta": tvshow_meta('tmdb_id', item[0], meta_user_info) }, watched_info, use_trakt, meta_user_info)['listitem'] xbmcplugin.addDirectoryItem(__handle__, listitem[0], listitem[1], isFolder=listitem[2]) check_meta_database() settings.check_database(WATCHED_DB) watched_info, use_trakt = get_watched_info_tv() meta_user_info = retrieve_user_info() window.clearProperty('fen_fanart_error') threads = [] dbcon = database.connect(WATCHED_DB) dbcur = dbcon.cursor() dbcur.execute( '''SELECT media_id, season, episode FROM progress WHERE db_type=? ORDER BY rowid DESC''', ('episode', )) rows = dbcur.fetchall() for item in rows: threads.append(Thread(target=process_eps, args=(item, ))) [i.start() for i in threads] [i.join() for i in threads] xbmcplugin.setContent(__handle__, 'episodes') xbmcplugin.endOfDirectory(__handle__) setView('view.episode_lists', 'episodes')
def furk_tfile_video(): params = dict(parse_qsl(sys.argv[2].replace('?',''))) t_files = [i for i in Furk.t_files(params.get('id')) if 'video' in i['ct'] and 'bitrate' in i] for count, item in enumerate(t_files, 1): try: cm = [] url_params = {'mode': 'media_play', 'url': item['url_dl'], 'rootname': 'video'} url = build_url(url_params) name = clean_file_name(item['name']).upper() if 1200 < int(item['height']) > 2100: display_res = '2160p' elif 1000 < int(item['height']) < 1200: display_res = '1080p' elif 680 < int(item['height']) < 1000: display_res = 'HD' else: display_res = 'SD' display_name = '%02d | [B]%s[/B] | [B]%.2f GB[/B] | %smbps | [I]%s[/I]' % \ (count, display_res, float(item['size'])/1073741824, str(round(float(item['bitrate'])/1000, 2)), name) listitem = xbmcgui.ListItem(display_name) down_file_params = {'mode': 'download_file', 'name': item['name'], 'url': item['url_dl'], 'db_type': 'furk_file', 'image': default_furk_icon} cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params))) listitem.addContextMenuItems(cm) listitem.setArt({'icon': default_furk_icon, 'poster': default_furk_icon, 'thumb': default_furk_icon, 'fanart': fanart, 'banner': default_furk_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def main(self): params = {'actor_id': self.actor_id, 'actor_name': self.actor_name, 'actor_image': self.actor_image} for menu_item in [('Movies', 'people_search.media_results'), ('TV Shows', 'people_search.media_results'), ('Biography', 'people_search.biography_results'), ('Images', 'people_search.image_results')]: if menu_item[0] == 'Movies': params['media_type'] = 'movies' elif menu_item[0] == 'TV Shows': params['media_type'] = 'tvshows' self._add_dir(menu_item[0], menu_item[1], params, isFolder=True) xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.main')
def ad_torrent_cloud(folder_id=None): cloud_files = [] cloud_dict = AllDebrid.user_cloud() try: for k, v in cloud_dict.iteritems(): if isinstance(v, dict): cloud_files.append(v) except: for k, v in cloud_dict.items(): if isinstance(v, dict): cloud_files.append(v) cloud_files = [i for i in cloud_files if i['statusCode'] == 4] for count, item in enumerate(cloud_files, 1): try: cm = [] folder_name = item['filename'] name = clean_file_name(folder_name).upper() display = '%02d | [B]FOLDER[/B] | [I]%s [/I]' % (count, name) url_params = { 'mode': 'alldebrid.browse_ad_cloud', 'folder': json.dumps(item) } link_folders_add = { 'mode': 'debrid_link_folders', 'debrid_service': 'AD', 'folder_name': normalize(folder_name), 'action': 'add' } link_folders_remove = { 'mode': 'debrid_link_folders', 'debrid_service': 'AD', 'folder_name': normalize(folder_name), 'action': 'remove' } url = build_url(url_params) cm.append(("[B]Link TV Show[/B]", 'XBMC.RunPlugin(%s)' % build_url(link_folders_add))) cm.append(("[B]Clear TV Show Link[/B]", 'XBMC.RunPlugin(%s)' % build_url(link_folders_remove))) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_ad_icon, 'poster': default_ad_icon, 'thumb': default_ad_icon, 'fanart': fanart, 'banner': default_ad_icon }) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def rd_downloads(): from modules.utils import jsondate_to_datetime try: my_downloads = RealDebrid.downloads() except: my_downloads = None if not my_downloads: return extensions = supported_video_extensions() my_downloads = [ i for i in my_downloads if i['download'].lower().endswith(tuple(extensions)) ] for count, item in enumerate(my_downloads, 1): try: cm = [] datetime_object = jsondate_to_datetime(item['generated'], "%Y-%m-%dT%H:%M:%S.%fZ", remove_time=True) filename = item['filename'] name = clean_file_name(filename).upper() size = float(int(item['filesize'])) / 1073741824 display = '%02d | %.2f GB | %s | [I]%s [/I]' % ( count, size, datetime_object, name) url_link = item['download'] url_params = { 'mode': 'media_play', 'url': url_link, 'rootname': 'video' } down_file_params = { 'mode': 'download_file', 'name': name, 'url': url_link, 'db_type': 'realdebrid_direct_file', 'image': default_rd_icon } cm.append(("[B]Download File[/B]", 'XBMC.RunPlugin(%s)' % build_url(down_file_params))) url = build_url(url_params) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_rd_icon, 'poster': default_rd_icon, 'thumb': default_rd_icon, 'fanart': fanart, 'banner': default_rd_icon }) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def my_furk_files(): try: params = dict(parse_qsl(sys.argv[2].replace('?',''))) files = eval('Furk.%s()' % params.get('list_type')) if params.get('list_type') in ('file_get_active', 'file_get_failed'): torrent_status_browser(files) else: furk_file_browser(files, params, display_mode='file_browse') except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def playAudioAlbum(self, t_files=None, name=None, from_seperate=False): import os import xbmcaddon from modules.utils import clean_file_name, batch_replace, to_utf8 from modules.nav_utils import setView icon_directory = settings.get_theme() default_furk_icon = os.path.join(icon_directory, 'furk.png') formats = ('.3gp', ''), ('.aac', ''), ('.flac', ''), ('.m4a', ''), ('.mp3', ''), \ ('.ogg', ''), ('.raw', ''), ('.wav', ''), ('.wma', ''), ('.webm', ''), ('.ra', ''), ('.rm', '') params = dict(parse_qsl(sys.argv[2].replace('?', ''))) furk_files_list = [] playlist = xbmc.PlayList(xbmc.PLAYLIST_MUSIC) playlist.clear() if from_seperate: t_files = [ i for i in t_files if clean_file_name(i['path']) == params.get('item_path') ] for item in t_files: try: name = item['path'] if not name else name if not 'audio' in item['ct']: continue url = item['url_dl'] track_name = clean_file_name( batch_replace(to_utf8(item['name']), formats)) listitem = xbmcgui.ListItem(track_name) listitem.setThumbnailImage(default_furk_icon) listitem.setInfo(type='music', infoLabels={ 'title': track_name, 'size': int(item['size']), 'album': clean_file_name( batch_replace(to_utf8(name), formats)), 'duration': item['length'] }) listitem.setProperty('mimetype', 'audio/mpeg') playlist.add(url, listitem) if from_seperate: furk_files_list.append((url, listitem, False)) except: pass self.play(playlist) if from_seperate: xbmcplugin.addDirectoryItems(__handle__, furk_files_list, len(furk_files_list)) setView('view.furk_files') xbmcplugin.endOfDirectory(__handle__)
def rd_torrent_cloud(): try: my_cloud_files = RealDebrid.user_cloud() except: my_cloud_files = None if not my_cloud_files: return my_cloud_files = [i for i in my_cloud_files if i['status'] == 'downloaded'] for count, item in enumerate(my_cloud_files, 1): try: cm = [] folder_name = item['filename'] name = clean_file_name(folder_name).upper() display = '%02d | [B]FOLDER[/B] | [I]%s [/I]' % (count, name) url_params = { 'mode': 'real_debrid.browse_rd_cloud', 'id': item['id'] } link_folders_add = { 'mode': 'debrid_link_folders', 'debrid_service': 'RD', 'folder_name': normalize(folder_name), 'action': 'add' } link_folders_remove = { 'mode': 'debrid_link_folders', 'debrid_service': 'RD', 'folder_name': normalize(folder_name), 'action': 'remove' } url = build_url(url_params) cm.append(("[B]Link TV Show[/B]", 'XBMC.RunPlugin(%s)' % build_url(link_folders_add))) cm.append(("[B]Clear TV Show Link[/B]", 'XBMC.RunPlugin(%s)' % build_url(link_folders_remove))) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_rd_icon, 'poster': default_rd_icon, 'thumb': default_rd_icon, 'fanart': fanart, 'banner': default_rd_icon }) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def image_results(self): results = TMDb.tmdb_people_pictures(self.actor_id) for item in results['profiles']: thumb_url = self.image_base % ('h632', item['file_path']) image_url = self.image_base % ('original', item['file_path']) name = '%sx%s' % (item['height'], item['width']) url_params = {'mode': 'show_image', 'image_url': image_url} url = build_url(url_params) listitem = xbmcgui.ListItem(name) listitem.setArt({'icon': thumb_url, 'poster': thumb_url, 'thumb': thumb_url, 'fanart': fanart, 'banner': thumb_url}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.main')
def torrent_status_browser(files): from datetime import timedelta from modules import fen_cache for count, item in enumerate(files, 1): try: display = '%02d | %s | [COLOR=grey][I]%s | %sGB | %s %% | SPEED: %s kB/s | (S:%s P:%s)[/I][/COLOR]' % (count, item['name'].replace('magnet:', '').upper(), item['dl_status'].upper(), str(round(float(item['size'])/1048576000, 1)), item['have'], str(round(float(item['speed'])/1024, 1)), item['seeders'], item['peers']) url_params = {'mode': 'furk.remove_from_downloads', 'name': item['name'], 'id': item['id']} url = build_url(url_params) listitem = xbmcgui.ListItem(display) listitem.setArt({'icon': default_furk_icon, 'poster': default_furk_icon, 'thumb': default_furk_icon, 'fanart': fanart, 'banner': default_furk_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass fen_cache.FenCache().set('furk_active_downloads', [i['info_hash'] for i in files], expiration=timedelta(hours=1)) xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def browse_audio_album(t_files=None, name=None): def build_list_object(): try: cm = [] url_params = {'mode': 'media_play', 'url': item['url_dl'], 'rootname': 'music'} url = build_url(url_params) track_name = clean_file_name(batch_replace(to_utf8(item['name']), formats)).upper() listitem = xbmcgui.ListItem(track_name) down_file_params = {'mode': 'download_file', 'name': item['name'], 'url': item['url_dl'], 'image': default_furk_icon, 'db_type': 'audio'} cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params))) listitem.addContextMenuItems(cm) listitem.setArt({'icon': default_furk_icon, 'poster': default_furk_icon, 'thumb': default_furk_icon, 'fanart': fanart, 'banner': default_furk_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass from modules.utils import batch_replace formats = ('.3gp', ''),('.aac', ''),('.flac', ''),('.m4a', ''),('.mp3', ''),('.ogg', ''),('.raw', ''),('.wav', ''),('.wma', ''),('.webm', ''),('.ra', ''),('.rm', '') params = dict(parse_qsl(sys.argv[2].replace('?',''))) seperate = False if not t_files: seperate = True t_fs = window.getProperty('furk_t_files_json') t_files = json.loads(t_fs) t_files = [i for i in t_files if 'audio' in i['ct']] if seperate: if dialog.yesno("Fen Music Player", 'Browse Songs or Play Full Album?', '', '', 'Play Now','Browse'): for item in t_files: item_path = clean_file_name(item['path']) if item_path == params.get('item_path'): build_list_object() xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.furk_files') else: from modules.player import FenPlayer FenPlayer().playAudioAlbum(t_files, from_seperate=True) else: for item in t_files: build_list_object() xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def pm_transfers(): extensions = supported_video_extensions() transfer_files = Premiumize.transfers_list()['transfers'] for count, item in enumerate(transfer_files, 1): try: cm = [] file_type = 'folder' if item['file_id'] is None else 'file' name = clean_file_name(item['name']).upper() status = item['status'] progress = item['progress'] if status == 'finished': progress = 100 else: try: progress = re.findall('\.(\d+)', str(progress))[0] progress = progress[:2] except: progress = '' if file_type == 'folder': display = '%02d | %s%% | [B]%s[/B] | [I]%s [/I]' % (count, str(progress), file_type.upper(), name) url_params = {'mode': 'premiumize.pm_torrent_cloud', 'id': item['folder_id'], 'folder_name': normalize(item['name'])} else: details = Premiumize.get_item_details(item['file_id']) url_link = details['link'] if url_link.startswith('/'): url_link = 'https' + url_link size = details['size'] display_size = float(int(size))/1073741824 display = '%02d | %s%% | [B]%s[/B] | %.2f GB | [I]%s [/I]' % (count, str(progress), file_type.upper(), display_size, name) url_params = {'mode': 'media_play', 'url': url_link, 'rootname': 'video'} down_file_params = {'mode': 'download_file', 'name': item['name'], 'url': url_link, 'db_type': 'premiumize_file', 'image': default_pm_icon} cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params))) url = build_url(url_params) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({'icon': default_pm_icon, 'poster': default_pm_icon, 'thumb': default_pm_icon, 'fanart': fanart, 'banner': default_pm_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def media_results(self, media_type, page_no, letter): from indexers.movies import Movies from indexers.tvshows import TVShows from modules.nav_utils import paginate_list, cached_page from modules.utils import title_key def _add_misc_dir(url_params, list_name='Next Page >>', info='Navigate to Next Page...', iconImage='item_next.png'): listitem = xbmcgui.ListItem(list_name, iconImage=os.path.join(icon_directory, iconImage)) listitem.setArt({'fanart': __addon__.getAddonInfo('fanart')}) listitem.setInfo('video', {'title': list_name, 'plot': info}) if url_params['mode'] == 'build_navigate_to_page': listitem.addContextMenuItems([("[B]Switch Jump To Action[/B]","XBMC.RunPlugin(%s)" % build_url({'mode': 'toggle_jump_to'}))]) xbmcplugin.addDirectoryItem(handle=__handle__, url=build_url(url_params), listitem=listitem, isFolder=True) not_widget = xbmc.getInfoLabel('Container.PluginName') cache_page = settings.cache_page() cache_page_string = 'people_search_%s_%s' % (media_type, self.actor_id) limit = 20 if cache_page: if not 'new_page' in params: silent = False if not_widget else True retrieved_page = cached_page(cache_page_string, silent=silent) if retrieved_page: page_no = retrieved_page try: builder = Movies if media_type == 'movies' else TVShows function = TMDb.tmdb_movies_actor_roles if media_type == 'movies' else TMDb.tmdb_tv_actor_roles content = 'movies' if media_type == 'movies' else 'tvshows' key = 'title' if media_type == 'movies' else 'name' result = function(self.actor_id) data = sorted(result, key=lambda k: title_key(k[key])) original_list = [{'media_id': i['id'], 'title': i[key]} for i in data] paginated_list, total_pages = paginate_list(original_list, page_no, letter, limit) media_list = [i['media_id'] for i in paginated_list] if total_pages > 2 and not_widget: _add_misc_dir({'mode': 'build_navigate_to_page', 'db_type': 'Media', 'media_type': media_type, 'actor_id': self.actor_id, 'actor_name': self.actor_name, 'actor_image': self.actor_image, 'current_page': page_no, 'total_pages': total_pages, 'transfer_mode': 'people_search.media_results'}, 'Jump To...', 'Jump To a Certain Page/Letter...', 'item_jump.png') builder(media_list, action='people_search_%s' % media_type).worker() if total_pages > page_no: _add_misc_dir({'mode': 'people_search.media_results', 'media_type': media_type, 'actor_id': self.actor_id, 'actor_name': self.actor_name, 'actor_image': self.actor_image, 'new_page': str(page_no + 1), 'new_letter': letter}) if cache_page: cached_page(cache_page_string, page_no=page_no) xbmcplugin.setContent(__handle__, content) xbmcplugin.endOfDirectory(__handle__) setView('view.%s' % content, content) except: notification('No Results', 3000)
def pm_torrent_cloud(folder_id=None, folder_name=None): try: extensions = supported_video_extensions() cloud_files = Premiumize.user_cloud(folder_id)['content'] cloud_files = [i for i in cloud_files if ('link' in i and i['link'].lower().endswith(tuple(extensions))) or i['type'] == 'folder'] cloud_files = sorted(cloud_files, key=lambda k: k['name']) cloud_files = sorted(cloud_files, key=lambda k: k['type'], reverse=True) except: return for count, item in enumerate(cloud_files, 1): try: cm = [] file_type = item['type'] name = clean_file_name(item['name']).upper() rename_params = {'mode': 'premiumize.rename', 'file_type': file_type, 'id': item['id'], 'name': item['name']} if file_type == 'folder': size = 0 display = '%02d | [B]%s[/B] | [I]%s [/I]' % (count, file_type.upper(), name) url_params = {'mode': 'premiumize.pm_torrent_cloud', 'id': item['id'], 'folder_name': normalize(item['name'])} else: url_link = item['link'] if url_link.startswith('/'): url_link = 'https' + url_link size = item['size'] display_size = float(int(size))/1073741824 display = '%02d | [B]%s[/B] | %.2f GB | [I]%s [/I]' % (count, file_type.upper(), display_size, name) url_params = {'mode': 'media_play', 'url': url_link, 'rootname': 'video'} down_file_params = {'mode': 'download_file', 'name': item['name'], 'url': url_link, 'db_type': 'premiumize_file', 'image': default_pm_icon} cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params))) cm.append(("[B]Rename %s[/B]" % file_type.capitalize(),'XBMC.RunPlugin(%s)' % build_url(rename_params))) url = build_url(url_params) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({'icon': default_pm_icon, 'poster': default_pm_icon, 'thumb': default_pm_icon, 'fanart': fanart, 'banner': default_pm_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def search_easynews(): from modules.history import add_to_search_history params = dict(parse_qsl(sys.argv[2].replace('?', ''))) default = params.get('suggestion', '') search_title = clean_file_name(params.get('query')) if ( 'query' in params and params.get('query') != 'NA') else None if not search_title: search_title = dialog.input('Enter search Term', type=xbmcgui.INPUT_ALPHANUM, defaultt=default) if not search_title: return try: search_name = clean_file_name(unquote(search_title)) add_to_search_history(search_name, 'easynews_video_queries') files = EasyNews.search(search_name) if not files: return dialog.ok('No results', 'No results') files = files[0:int(__addon__.getSetting('easynews_limit'))] easynews_file_browser(files) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def furk_tfile_audio(): window.clearProperty('furk_t_files_json') params = dict(parse_qsl(sys.argv[2].replace('?',''))) excludes = ['', 'cover', 'covers', 'scan', 'scans', 'playlists'] t_files = Furk.t_files(params.get('id')) item_path_list = sorted(list(set([clean_file_name(i['path']) for i in t_files if clean_file_name(i['path']).lower() not in excludes]))) if not item_path_list: if dialog.yesno("Fen Music Player", 'Browse Songs or Play Full Album?', '', '', 'Play Now','Browse'): return browse_audio_album(t_files, params.get('name')) from modules.player import FenPlayer FenPlayer().playAudioAlbum(t_files, params.get('name')) return browse_audio_album(t_files, params.get('name')) for x in item_path_list: url_params = {'mode': 'furk.browse_audio_album', 'item_path': x} url = build_url(url_params) listitem = xbmcgui.ListItem(x.upper()) listitem.setArt({'icon': default_furk_icon, 'poster': default_furk_icon, 'thumb': default_furk_icon, 'fanart': fanart, 'banner': default_furk_icon}) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) t_files_json = json.dumps(t_files) window.setProperty('furk_t_files_json', str(t_files_json)) xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def search_furk(): from modules.history import add_to_search_history params = dict(parse_qsl(sys.argv[2].replace('?',''))) default = params.get('suggestion', '') search_title = clean_file_name(params.get('query')) if ('query' in params and params.get('query') != 'NA') else None if not search_title: search_title = dialog.input('Enter search Term', type=xbmcgui.INPUT_ALPHANUM, defaultt=default) if not search_title: return try: search_name = clean_file_name(urllib.unquote(search_title)) search_method = 'search' if 'accurate_search' in params else 'direct_search' search_setting = 'furk_video_queries' if params.get('db_type') == 'video' else 'furk_audio_queries' list_type = 'video' if params.get('db_type') == 'video' else 'audio' add_to_search_history(search_name, search_setting) files = Furk.direct_search(search_name) if search_method == 'direct_search' else Furk.search(search_name) if not files: return dialog.ok('No results', 'No results') if not settings.include_uncached_results(): try: files = [i for i in files if i.get('is_ready', '0') == '1' and i['type'] == list_type] except: return dialog.ok('No results', 'No results') files = files[0:int(__addon__.getSetting('furk.limit'))] furk_file_browser(files, params, display_mode='search') except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def browse_ad_cloud(folder): final_files = [] extensions = supported_video_extensions() torrent_folder = json.loads(folder) links = torrent_folder['links'] total_size = torrent_folder['size'] try: links_count = len([ v for k, v in links.items() if v.lower().endswith(tuple(extensions)) ]) for k, v in links.items(): if v.lower().endswith(tuple(extensions)): size = total_size / links_count final_files.append({'name': v, 'down_url': k, 'size': size}) except: links_count = len([ v for k, v in links.iteritems() if v.lower().endswith(tuple(extensions)) ]) for k, v in links.iteritems(): if v.lower().endswith(tuple(extensions)): size = total_size / links_count final_files.append({'name': v, 'down_url': k, 'size': size}) for count, item in enumerate(final_files, 1): try: cm = [] url_link = item['down_url'] name = clean_file_name(item['name']).upper() size = item['size'] display_size = float(int(size)) / 1073741824 display = '%02d | %.2f GB | [I]%s [/I]' % (count, display_size, name) url_params = {'mode': 'alldebrid.resolve_ad', 'url': url_link} url = build_url(url_params) down_file_params = { 'mode': 'download_file', 'name': name, 'url': url_link, 'db_type': 'alldebrid_file', 'image': default_ad_icon } cm.append(("[B]Download File[/B]", 'XBMC.RunPlugin(%s)' % build_url(down_file_params))) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_ad_icon, 'poster': default_ad_icon, 'thumb': default_ad_icon, 'fanart': fanart, 'banner': default_ad_icon }) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def search_history(): import xbmc, xbmcgui, xbmcplugin import sys, os try: from urlparse import parse_qsl except ImportError: from urllib.parse import parse_qsl try: from urllib import unquote except ImportError: from urllib.parse import unquote from modules.nav_utils import build_url, setView from modules.settings import get_theme try: params = dict(parse_qsl(sys.argv[2].replace('?', ''))) (search_setting, display_title) = ('movie_queries', 'MOVIE') if params['action'] == 'movie' \ else ('tvshow_queries', 'TVSHOW') if params['action'] == 'tvshow' \ else ('people_queries', 'PEOPLE') if params['action'] == 'people' \ else ('furk_video_queries', 'FURK VIDEO') if params['action'] == 'furk_video' \ else ('furk_audio_queries', 'FURK AUDIO') if params['action'] == 'furk_audio' \ else ('easynews_video_queries', 'EASYNEWS VIDEO') if params['action'] == 'easynews_video' \ else '' history = _cache.get(search_setting) if not history: return except: return icon = os.path.join(get_theme(), 'search.png') fanart = os.path.join(xbmc.translatePath(__addon__.getAddonInfo('path')), 'fanart.png') for h in history: try: cm = [] name = unquote(h) url_params = {'mode': 'build_movie_list', 'action': 'tmdb_movies_search', 'query': name} if params['action'] == 'movie' \ else {'mode': 'build_tvshow_list', 'action': 'tmdb_tv_search', 'query': name} if params['action'] == 'tvshow' \ else {'mode': 'people_search.search', 'actor_name': name} if params['action'] == 'people' \ else {'mode': 'furk.search_furk', 'db_type': 'video', 'query': name} if params['action'] == 'furk_video' \ else {'mode': 'furk.search_furk', 'db_type': 'audio', 'music': True, 'query': name} if params['action'] == 'furk_audio' \ else {'mode': 'easynews.search_easynews', 'query': name} if params['action'] == 'easynews_video' \ else '' display = '[B]%s SEARCH : [/B]' % display_title + name url = build_url(url_params) cm.append(("[B]Remove from history[/B]",'XBMC.RunPlugin(%s?mode=%s&setting_id=%s&name=%s)' \ % (sys.argv[0], 'remove_from_history', search_setting, name))) listitem = xbmcgui.ListItem(display) listitem.setArt({ 'icon': icon, 'poster': icon, 'thumb': icon, 'fanart': fanart, 'banner': icon }) listitem.addContextMenuItems(cm) xbmcplugin.addDirectoryItem(int(sys.argv[1]), url, listitem, isFolder=True) except: pass xbmcplugin.setContent(int(sys.argv[1]), 'addons') xbmcplugin.endOfDirectory(int(sys.argv[1])) setView('view.main')
def build_season_list(): def _build(item, item_position=None): try: cm = [] overview = item['overview'] name = item['name'] poster_path = item['poster_path'] season_number = item['season_number'] episode_count = item['episode_count'] plot = overview if overview != '' else show_plot title = name if use_season_title and name != '' else 'Season %s' % str(season_number) season_poster = poster_path if poster_path is not None else show_poster playcount, overlay, watched, unwatched = get_watched_status_season(watched_info, use_trakt, tmdb_id, season_number, episode_count) watched_params = {"mode": "mark_season_as_watched_unwatched", "action": 'mark_as_watched', "title": show_title, "year": show_year, "media_id": tmdb_id, "imdb_id": imdb_id, "tvdb_id": tvdb_id, "season": season_number, "meta_user_info": meta_user_info} unwatched_params = {"mode": "mark_season_as_watched_unwatched", "action": 'mark_as_unwatched', "title": show_title, "year": show_year, "media_id": tmdb_id, "imdb_id": imdb_id, "tvdb_id": tvdb_id, "season": season_number, "meta_user_info": meta_user_info} playback_menu_params = {'mode': 'playback_menu'} cm.append(("[B]Mark Watched %s[/B]" % watched_title,'XBMC.RunPlugin(%s)' % build_url(watched_params))) cm.append(("[B]Mark Unwatched %s[/B]" % watched_title,'XBMC.RunPlugin(%s)' % build_url(unwatched_params))) cm.append(("[B]Options[/B]",'XBMC.RunPlugin(%s)' % build_url(playback_menu_params))) cm.append(("[B]Extended Info[/B]", 'RunScript(script.extendedinfo,info=extendedtvinfo,id=%s)' % tmdb_id)) url_params = {'mode': 'build_episode_list', 'tmdb_id': tmdb_id, 'season': season_number} url = build_url(url_params) listitem = xbmcgui.ListItem() listitem.setLabel(title) try: listitem.setProperties({'watchedepisodes': str(watched), 'unwatchedepisodes': str(unwatched), 'totalepisodes': str(episode_count)}) except: listitem.setProperty('watchedepisodes', str(watched)) listitem.setProperty('unwatchedepisodes', str(unwatched)) listitem.setProperty('totalepisodes', str(episode_count)) listitem.addContextMenuItems(cm) listitem.setArt({'poster': season_poster, 'fanart': fanart, 'banner': banner, 'clearart': clearart, 'clearlogo': clearlogo, 'landscape': landscape}) listitem.setCast(cast) listitem.setUniqueIDs({'imdb': str(imdb_id), 'tmdb': str(tmdb_id), 'tvdb': str(tvdb_id)}) listitem.setInfo( 'video', {'mediatype': 'tvshow', 'trailer': trailer, 'title': show_title, 'size': '0', 'duration': episode_run_time, 'plot': plot, 'rating': rating, 'premiered': premiered, 'studio': studio, 'year': show_year,'genre': genre, 'mpaa': mpaa, 'tvshowtitle': show_title, 'imdbnumber': imdb_id,'votes': votes, 'episode': str(episode_count),'playcount': playcount, 'overlay': overlay}) if use_threading: item_list.append({'list_item': (url, listitem, True), 'item_position': item_position}) else: xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass params = dict(parse_qsl(sys.argv[2].replace('?',''))) meta_user_info = tikimeta.retrieve_user_info() if 'meta' in params: meta = json.loads(params.get('meta')) else: window.clearProperty('fen_fanart_error') meta = tikimeta.tvshow_meta('tmdb_id', params.get('tmdb_id'), meta_user_info) season_data = tikimeta.all_episodes_meta(meta['tmdb_id'], meta['tvdb_id'], meta['tvdb_summary']['airedSeasons'], meta['season_data'], meta_user_info) if not season_data: return meta_user_info = json.dumps(meta_user_info) tmdb_id = meta['tmdb_id'] tvdb_id = meta['tvdb_id'] imdb_id = meta['imdb_id'] show_title = meta['title'] show_year = meta['year'] show_poster = meta['poster'] show_plot = meta['plot'] fanart = meta['fanart'] banner = meta['banner'] clearlogo = meta['clearlogo'] clearart = meta['clearart'] landscape = meta['landscape'] cast = meta['cast'] mpaa = meta['mpaa'] trailer = str(meta['trailer']) episode_run_time = meta.get('episode_run_time') rating = meta.get('rating') premiered = meta.get('premiered') studio = meta.get('studio') genre = meta.get('genre') votes = meta.get('votes') if not settings.show_specials(): season_data = [i for i in season_data if not i['season_number'] == 0] season_data = sorted(season_data, key=lambda i: i['season_number']) use_season_title = settings.use_season_title() watched_indicators = settings.watched_indicators() watched_title = 'Trakt' if watched_indicators in (1, 2) else "Fen" use_threading = settings.thread_main_menus() watched_info, use_trakt = get_watched_info_tv() if use_threading: item_list = [] threads = [] for item_position, item in enumerate(season_data): threads.append(Thread(target=_build, args=(item, item_position))) [i.start() for i in threads] [i.join() for i in threads] item_list.sort(key=lambda k: k['item_position']) xbmcplugin.addDirectoryItems(__handle__, [i['list_item'] for i in item_list]) else: for item in season_data: _build(item) xbmcplugin.setContent(__handle__, 'seasons') xbmcplugin.endOfDirectory(__handle__) setView('view.seasons', 'seasons') window.setProperty('fen_media_meta', json.dumps(meta))
def fetch_list(self): try: params = dict(parse_qsl(sys.argv[2].replace('?',''))) worker = True mode = params.get('mode') cache_page = settings.cache_page() try: page_no = int(params.get('new_page', '1')) except ValueError: page_no = params.get('new_page') if cache_page: if self.action == 'tmdb_tv_discover': self.cache_page_string = params['name'] if not 'new_page' in params: silent = True if is_widget else False retrieved_page = cached_page(self.cache_page_string, silent=silent) if retrieved_page: page_no = retrieved_page letter = params.get('new_letter', 'None') content_type = 'tvshows' var_module = 'tmdb_api' if 'tmdb' in self.action else 'trakt_api' if 'trakt' in self.action else 'imdb_api' if 'imdb' in self.action else None if var_module: try: module = 'apis.%s' % (var_module) function = getattr(importlib.import_module(module), self.action) except: pass if self.action in ('tmdb_tv_popular','tmdb_tv_top_rated', 'tmdb_tv_premieres','tmdb_tv_upcoming', 'tmdb_tv_airing_today','tmdb_tv_on_the_air','trakt_tv_anticipated','trakt_tv_trending'): data = function(page_no) if 'tmdb' in self.action: for item in data['results']: self.list.append(item['id']) else: for item in data: self.list.append(get_trakt_tvshow_id(item['show']['ids'])) self.new_page = {'mode': mode, 'action': self.action, 'new_page': str((data['page'] if 'tmdb' in self.action else page_no) + 1), 'foldername': self.action} elif self.action == 'tmdb_tv_discover': from modules.discover import set_history name = params['name'] query = params['query'] if page_no == 1: set_history('tvshow', name, query) data = function(query, page_no) for item in data['results']: self.list.append(item['id']) if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'query': query, 'name': name, 'new_page': str(data['page'] + 1), 'foldername': self.action} elif self.action in ('trakt_collection', 'trakt_watchlist', 'trakt_collection_widgets'): data, total_pages = function('shows', page_no, letter) self.list = [i['media_id'] for i in data] if total_pages > 2: self.total_pages = total_pages if total_pages > page_no: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(page_no + 1), 'new_letter': letter, 'foldername': self.action} elif self.action == ('trakt_tv_mosts'): for item in function(params['period'], params['duration'], page_no): self.list.append((get_trakt_tvshow_id(item['show']['ids']))) self.new_page = {'mode': mode, 'action': self.action, 'period': params['period'], 'duration': params['duration'], 'new_page': str(page_no + 1), 'foldername': self.action} elif self.action == 'tmdb_tv_genres': genre_id = params['genre_id'] if 'genre_id' in params else self.multiselect_genres(params.get('genre_list')) if not genre_id: return data = function(genre_id, page_no) self.list = [i['id'] for i in data['results']] if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(data['page'] + 1), 'genre_id': genre_id, 'foldername': genre_id} elif self.action == 'tmdb_tv_languages': language = params['language'] if not language: return data = function(language, page_no) self.list = [i['id'] for i in data['results']] if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(data['page'] + 1), 'language': language, 'foldername': language} elif self.action == 'tmdb_tv_networks': data = function(params['network_id'], page_no) self.list = [i['id'] for i in data['results']] if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(data['page'] + 1), 'network_id': params['network_id'], 'foldername': params['network_id']} elif self.action == 'trakt_tv_certifications': for item in function(params['certification'], page_no): self.list.append((get_trakt_tvshow_id(item['show']['ids']))) self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(page_no + 1), 'foldername': params['certification'], 'certification': params['certification']} elif self.action == 'tmdb_tv_year': data = function(params['year'], page_no) self.list = [i['id'] for i in data['results']] if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(page_no + 1), 'year': params['year'], 'foldername': params['year']} elif self.action in ('in_progress_tvshows', 'favourites_tvshows', 'subscriptions_tvshows', 'kodi_library_tvshows', 'watched_tvshows'): (var_module, import_function) = ('in_progress', 'in_progress_tvshow') if 'in_progress' in self.action else ('favourites', 'retrieve_favourites') if 'favourites' in self.action else ('subscriptions', 'retrieve_subscriptions') if 'subscriptions' in self.action else ('indicators_bookmarks', 'get_watched_items') if 'watched' in self.action else ('kodi_library', 'retrieve_kodi_library') if 'library' in self.action else '' try: module = 'modules.%s' % (var_module) function = getattr(importlib.import_module(module), import_function) except: pass if self.action == 'kodi_library_tvshows': self.id_type = 'tvdb_id' data, total_pages = function('tvshow', page_no, letter) self.list = [i['media_id'] for i in data] if total_pages > 2: self.total_pages = total_pages if total_pages > page_no: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(page_no + 1), 'new_letter': letter, 'foldername': self.action} elif self.action in ('tmdb_tv_similar', 'tmdb_tv_recommendations'): self.sim_recom_name = params['sim_recom_name'] self.sim_recom_tmdb = params['sim_recom_tmdb'] data = function(self.sim_recom_tmdb, page_no) self.list = [i['id'] for i in data['results']] if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(data['page'] + 1), 'sim_recom_name': self.sim_recom_name, 'sim_recom_tmdb': self.sim_recom_tmdb, 'foldername': self.action} elif self.action == 'trakt_recommendations': for item in function('shows'): self.list.append(get_trakt_tvshow_id(item['ids'])) elif self.action == 'tmdb_popular_people': import os worker = False icon_directory = settings.get_theme() data = function(page_no) content_type = 'addons' fanart = __addon__.getAddonInfo('fanart') for item in data['results']: cm = [] actor_poster = "http://image.tmdb.org/t/p/original%s" % item['profile_path'] if item['profile_path'] else os.path.join(icon_directory, 'genre_family.png') url_params = {'mode': 'people_search.main', 'actor_id': item['id'], 'actor_name': item['name'], 'actor_image': actor_poster.replace('w185', 'h632')} cm.append(("[B]Extended Info[/B]", 'RunScript(script.extendedinfo,info=extendedactorinfo,id=%s)' % item['id'])) url = build_url(url_params) listitem = xbmcgui.ListItem(item['name']) listitem.setArt({'icon': actor_poster, 'poster': actor_poster, 'thumb': actor_poster, 'fanart': fanart, 'banner': actor_poster}) listitem.addContextMenuItems(cm) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) if data['page'] < data['total_pages']: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(int(data['page']) + 1), 'foldername': self.action} elif self.action == 'tmdb_tv_search': try: from urllib import unquote except ImportError: from urllib.parse import unquote if params.get('query') == 'NA': search_title = dialog.input("Search Fen", type=xbmcgui.INPUT_ALPHANUM) search_name = unquote(search_title) else: search_name = unquote(params.get('query')) if not search_name: return params['search_name'] = search_name data = function(search_name, page_no) total_pages = data['total_pages'] if total_pages > page_no: self.new_page = {'mode': mode, 'action': self.action, 'new_page': str(page_no + 1), 'query': search_name, 'foldername': search_name} self.list = [i['id'] for i in data['results']] if self.total_pages and not is_widget: url_params = {'mode': 'build_navigate_to_page', 'db_type': 'TV Shows', 'current_page': page_no, 'total_pages': self.total_pages, 'transfer_mode': mode, 'transfer_action': self.action, 'foldername': self.action, 'query': params.get('search_name', ''), 'actor_id': params.get('actor_id', '')} self.add_dir(url_params, 'Jump To...', 'Jump To a Certain Page/Letter...', 'item_jump.png') if cache_page: cached_page(self.cache_page_string, page_no=page_no) if worker: self.worker() if self.new_page: self.add_dir(self.new_page) except: pass xbmcplugin.setContent(__handle__, content_type) xbmcplugin.endOfDirectory(__handle__) if params.get('refreshed') == 'true': xbmc.sleep(1500) setView('view.tvshows', content_type)
def build_episode_list(): def _build(item): try: cm = [] season = item['season'] episode = item['episode'] ep_name = item['title'] premiered = item['premiered'] playcount, overlay = get_watched_status(watched_info, use_trakt, 'episode', tmdb_id, season, episode) resumetime = get_resumetime('episode', tmdb_id, season, episode) query = title + ' S%.2dE%.2d' % (int(season), int(episode)) display_name = '%s - %dx%.2d' % (title, season, episode) thumb = item['thumb'] if 'episodes' in item['thumb'] else fanart meta.update({'vid_type': 'episode', 'rootname': display_name, 'season': season, 'episode': episode, 'premiered': premiered, 'ep_name': ep_name, 'plot': item['plot']}) item.update({'trailer': trailer, 'tvshowtitle': title, 'genre': genre, 'duration': duration, 'mpaa': mpaa, 'studio': studio, 'playcount': playcount, 'overlay': overlay}) meta_json = json.dumps(meta) url_params = {'mode': 'play_media', 'vid_type': 'episode', 'tmdb_id': tmdb_id, 'query': query, 'tvshowtitle': meta['rootname'], 'season': season, 'episode': episode, 'meta': meta_json} url = build_url(url_params) try: d = premiered.split('-') episode_date = date(int(d[0]), int(d[1]), int(d[2])) except: episode_date = date(2000,1,1) if season == 0 else None unaired = False display = ep_name if not episode_date or current_adjusted_date < episode_date: unaired = True display = '[I][COLOR %s]%s[/COLOR][/I]' % (UNAIRED_EPISODE_COLOUR, ep_name) item['title'] = display item['sortseason'] = season item['sortepisode'] = episode (state, action) = ('Watched', 'mark_as_watched') if playcount == 0 else ('Unwatched', 'mark_as_unwatched') playback_menu_params = {'mode': 'playback_menu', 'suggestion': query, 'play_params': json.dumps(url_params)} if not unaired: watched_unwatched_params = {"mode": "mark_episode_as_watched_unwatched", "action": action, "media_id": tmdb_id, "imdb_id": imdb_id, "tvdb_id": tvdb_id, "season": season, "episode": episode, "title": title, "year": year} cm.append(("[B]Mark %s %s[/B]" % (state, watched_title),'RunPlugin(%s)' % build_url(watched_unwatched_params))) cm.append(("[B]Options[/B]",'RunPlugin(%s)' % build_url(playback_menu_params))) if not unaired and resumetime != '0': cm.append(("[B]Clear Progress[/B]", 'RunPlugin(%s)' % build_url({"mode": "watched_unwatched_erase_bookmark", "db_type": "episode", "media_id": tmdb_id, "season": season, "episode": episode, "refresh": "true"}))) cm.append(("[B]Extended Info[/B]", 'RunScript(script.extendedinfo,info=extendedtvinfo,id=%s)' % tmdb_id)) listitem = xbmcgui.ListItem() listitem.setLabel(display) listitem.setProperty("resumetime", resumetime) listitem.addContextMenuItems(cm) listitem.setArt({'poster': show_poster, 'fanart': fanart, 'thumb': thumb, 'banner': banner, 'clearart': clearart, 'clearlogo': clearlogo, 'landscape': landscape}) listitem.setCast(cast) listitem.setUniqueIDs({'imdb': str(imdb_id), 'tmdb': str(tmdb_id), 'tvdb': str(tvdb_id)}) listitem.setInfo('video', remove_unwanted_info_keys(item)) if is_widget: try: listitem.setProperties({'fen_widget': 'true', 'fen_playcount': str(playcount), 'fen_playback_menu_params': json.dumps(playback_menu_params)}) except: listitem.setProperty("fen_widget", 'true') listitem.setProperty("fen_playcount", str(playcount)) listitem.setProperty("fen_playback_menu_params", json.dumps(playback_menu_params)) if use_threading: item_list.append((url, listitem, False)) else: xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=False) except: pass UNAIRED_EPISODE_COLOUR = settings.unaired_episode_colour() if not UNAIRED_EPISODE_COLOUR or UNAIRED_EPISODE_COLOUR == '': UNAIRED_EPISODE_COLOUR = 'red' params = dict(parse_qsl(sys.argv[2].replace('?',''))) meta_user_info = tikimeta.retrieve_user_info() all_episodes = True if params.get('season') == 'all' else False if all_episodes: if 'meta' in params: meta = json.loads(params.get('meta')) else: window.clearProperty('fen_fanart_error') meta = tikimeta.tvshow_meta('tmdb_id', params.get('tmdb_id'), meta_user_info) else: try: meta = json.loads(window.getProperty('fen_media_meta')) except: window.clearProperty('fen_fanart_error') meta = tikimeta.tvshow_meta('tmdb_id', params.get('tmdb_id'), meta_user_info) tmdb_id = meta['tmdb_id'] tvdb_id = meta['tvdb_id'] imdb_id = meta['imdb_id'] title = meta['title'] year = meta['year'] rootname = meta['rootname'] show_poster = meta['poster'] fanart = meta['fanart'] banner = meta['banner'] clearlogo = meta['clearlogo'] clearart = meta['clearart'] landscape = meta['landscape'] cast = meta['cast'] mpaa = meta['mpaa'] duration = meta.get('duration') trailer = str(meta['trailer']) genre = meta.get('genre') studio = meta.get('studio') watched_indicators = settings.watched_indicators() current_adjusted_date = settings.adjusted_datetime() watched_title = 'Trakt' if watched_indicators in (1, 2) else "Fen" episodes_data = tikimeta.season_episodes_meta(tmdb_id, tvdb_id, params.get('season'), meta['tvdb_summary']['airedSeasons'], meta['season_data'], meta_user_info, all_episodes) if all_episodes: if not settings.show_specials(): episodes_data = [i for i in episodes_data if not i['season'] == 0] episodes_data = sorted(episodes_data, key=lambda i: i['episode']) watched_info, use_trakt = get_watched_info_tv() use_threading = settings.thread_main_menus() if use_threading: item_list = [] threads = [] for item in episodes_data: threads.append(Thread(target=_build, args=(item,))) [i.start() for i in threads] [i.join() for i in threads] xbmcplugin.addDirectoryItems(__handle__, item_list) else: for item in episodes_data: _build(item) xbmcplugin.setContent(__handle__, 'episodes') xbmcplugin.addSortMethod(__handle__, xbmcplugin.SORT_METHOD_EPISODE) xbmcplugin.endOfDirectory(__handle__) setView('view.episodes', 'episodes')
def browse_rd_cloud(folder_id): try: torrent_files = RealDebrid.user_cloud_info(folder_id) except: return extensions = supported_video_extensions() try: file_info = [ i for i in torrent_files['files'] if i['path'].lower().endswith(tuple(extensions)) ] file_urls = torrent_files['links'] for c, i in enumerate(file_info): try: i.update({'url_link': file_urls[c]}) except: pass pack_info = sorted(file_info, key=lambda k: k['path']) except: return xbmcgui.Dialog().ok('Fen - Real Debrid', 'Cannot display Malformed Pack.') for count, item in enumerate(pack_info, 1): try: cm = [] name = item['path'] if name.startswith('/'): name = name.split('/')[-1] name = clean_file_name(name).upper() url_link = item['url_link'] if url_link.startswith('/'): url_link = 'http' + url_link size = float(int(item['bytes'])) / 1073741824 display = '%02d | [B]FILE[/B] | %.2f GB | [I]%s [/I]' % ( count, size, name) url_params = {'mode': 'real_debrid.resolve_rd', 'url': url_link} url = build_url(url_params) down_file_params = { 'mode': 'download_file', 'name': name, 'url': url_link, 'db_type': 'realdebrid_file', 'image': default_rd_icon } cm.append(("[B]Download File[/B]", 'XBMC.RunPlugin(%s)' % build_url(down_file_params))) listitem = xbmcgui.ListItem(display) listitem.addContextMenuItems(cm) listitem.setArt({ 'icon': default_rd_icon, 'poster': default_rd_icon, 'thumb': default_rd_icon, 'fanart': fanart, 'banner': default_rd_icon }) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'files') xbmcplugin.endOfDirectory(__handle__) setView('view.premium')
def build_next_episode(): from modules.indicators_bookmarks import get_watched_info_tv check_meta_database() clear_all_trakt_cache_data(confirm=False) sync_watched_trakt_to_fen() try: threads = [] seen = set() ep_list = [] nextep_settings = settings.nextep_content_settings() nextep_display_settings = settings.nextep_display_settings() watched_info, use_trakt = get_watched_info_tv() meta_user_info = retrieve_user_info() cache_to_disk = nextep_settings['cache_to_disk'] nextep_display_settings['cache_to_disk'] = cache_to_disk window.setProperty('fen_fanart_error', 'true') if nextep_settings['include_unwatched']: for i in get_unwatched_next_episodes(): ep_list.append(i) if settings.watched_indicators() in (1, 2): from apis.trakt_api import trakt_get_next_episodes ep_list += trakt_get_next_episodes() else: settings.check_database(WATCHED_DB) dbcon = database.connect(WATCHED_DB) dbcur = dbcon.cursor() dbcur.execute( '''SELECT media_id, season, episode, last_played FROM watched_status WHERE db_type=?''', ('episode', )) rows = dbcur.fetchall() rows = sorted(rows, key=lambda x: (x[0], x[1], x[2]), reverse=True) [ ep_list.append({ "tmdb_id": a, "season": int(b), "episode": int(c), "last_played": d }) for a, b, c, d in rows if not (a in seen or seen.add(a)) ] ep_list = [ x for x in ep_list if x['tmdb_id'] not in check_for_next_episode_excludes() ] ep_list = [i for i in ep_list if not i['tmdb_id'] == None] for item in ep_list: threads.append( Thread(target=process_eps, args=(item, nextep_settings, nextep_display_settings, watched_info, use_trakt, meta_user_info))) [i.start() for i in threads] [i.join() for i in threads] r = [i for i in result if i is not None] r = sort_next_eps(r, nextep_settings) item_list = [i['listitem'] for i in r] for i in item_list: xbmcplugin.addDirectoryItem(__handle__, i[0], i[1], i[2]) xbmcplugin.setContent(__handle__, 'episodes') xbmcplugin.endOfDirectory(__handle__, cacheToDisc=cache_to_disk) setView('view.episode_lists', 'episodes') except: from modules.nav_utils import notification notification('Error getting Next Episode Info', time=3500) pass
def build_next_episode_manager(): from modules.nav_utils import add_dir from modules.indicators_bookmarks import get_watched_status_tvshow, get_watched_info_tv def _process(tmdb_id, action): try: meta = tvshow_meta('tmdb_id', tmdb_id, meta_user_info) title = meta['title'] if action == 'manage_unwatched': action, display = 'remove', '[COLOR=%s][UNWATCHED][/COLOR] %s' % ( NEXT_EP_UNWATCHED, title) url_params = { 'mode': 'add_next_episode_unwatched', 'action': 'remove', 'tmdb_id': tmdb_id, 'title': title } elif action == 'trakt_and_fen': action, display = 'unhide' if tmdb_id in exclude_list else 'hide', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % title url_params = { "mode": "hide_unhide_trakt_items", "action": action, "media_type": "shows", "media_id": meta['imdb_id'], "section": "progress_watched" } else: action, display = 'remove' if tmdb_id in exclude_list else 'add', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % title url_params = { 'mode': 'add_to_remove_from_next_episode_excludes', 'action': action, 'title': title, 'media_id': tmdb_id } sorted_list.append({ 'tmdb_id': tmdb_id, 'display': display, 'url_params': url_params, 'meta': json.dumps(meta) }) except: pass check_meta_database() clear_all_trakt_cache_data(confirm=False) sync_watched_trakt_to_fen() params = dict(parse_qsl(sys.argv[2].replace('?', ''))) NEXT_EP_UNWATCHED = __addon__.getSetting('nextep.unwatched_colour') if not NEXT_EP_UNWATCHED or NEXT_EP_UNWATCHED == '': NEXT_EP_UNWATCHED = 'red' threads = [] sorted_list = [] action = params['action'] if action == 'manage_unwatched': tmdb_list = [i['tmdb_id'] for i in get_unwatched_next_episodes()] heading = 'Select Show to remove from Fen Next Episode:' elif settings.watched_indicators() in (1, 2): from apis.trakt_api import trakt_get_next_episodes tmdb_list, exclude_list = trakt_get_next_episodes(include_hidden=True) heading = 'Select Show to Hide/Unhide from Trakt Progress:' action = 'trakt_and_fen' else: settings.check_database(WATCHED_DB) dbcon = database.connect(WATCHED_DB) dbcur = dbcon.cursor() dbcur.execute( '''SELECT media_id FROM watched_status WHERE db_type=? GROUP BY media_id''', ('episode', )) rows = dbcur.fetchall() tmdb_list = [row[0] for row in rows] exclude_list = check_for_next_episode_excludes() heading = 'Select Show to Include/Exclude in Fen Next Episode:' add_dir({'mode': 'nill'}, '[I][COLOR=grey][B]INFO:[/B][/COLOR] [COLOR=grey2]%s[/COLOR][/I]' % heading, iconImage='settings.png') if not tmdb_list: from modules.nav_utils import notification return notification('No Shows Present', time=5000) meta_user_info = retrieve_user_info() window.setProperty('fen_fanart_error', 'true') for tmdb_id in tmdb_list: threads.append(Thread(target=_process, args=(tmdb_id, action))) [i.start() for i in threads] [i.join() for i in threads] sorted_items = sorted(sorted_list, key=lambda k: k['display']) watched_info, use_trakt = get_watched_info_tv() for i in sorted_items: try: cm = [] meta = json.loads(i['meta']) playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow( watched_info, use_trakt, meta['tmdb_id'], meta.get('total_episodes')) meta.update({ 'playcount': playcount, 'overlay': overlay, 'total_watched': str(total_watched), 'total_unwatched': str(total_unwatched) }) url = build_url(i['url_params']) browse_url = build_url({ 'mode': 'build_season_list', 'meta': i['meta'] }) cm.append( ("[B]Browse...[/B]", 'XBMC.Container.Update(%s)' % browse_url)) listitem = xbmcgui.ListItem(i['display']) listitem.setProperty('watchedepisodes', str(total_watched)) listitem.setProperty('unwatchedepisodes', str(total_unwatched)) listitem.setProperty('totalepisodes', str(meta['total_episodes'])) listitem.setProperty('totalseasons', str(meta['total_seasons'])) listitem.addContextMenuItems(cm) listitem.setArt({ 'poster': meta['poster'], 'fanart': meta['fanart'], 'banner': meta['banner'], 'clearart': meta['clearart'], 'clearlogo': meta['clearlogo'], 'landscape': meta['landscape'] }) listitem.setCast(meta['cast']) listitem.setInfo('video', remove_unwanted_info_keys(meta)) xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True) except: pass xbmcplugin.setContent(__handle__, 'tvshows') xbmcplugin.endOfDirectory(__handle__, cacheToDisc=False) setView('view.main', 'tvshows')
def _end_directory(self): xbmcplugin.setContent(__handle__, 'addons') xbmcplugin.endOfDirectory(__handle__) setView(self.view, 'addons')
def build_kodi_library_recently_added(db_type): import xbmcplugin from modules.nav_utils import setView limit = int(__addon__.getSetting('recent_added_limit')) recent_added = [] results = [] if db_type in ('movie', 'movies'): from indexers.movies import Movies db_type = 'movies' view_type = 'view.movies' try: JSON_req = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetRecentlyAddedMovies", \ "params": {"properties": ["title", "imdbnumber"]},"id": "1"}' r = xbmc.executeJSONRPC(JSON_req) r = to_utf8(json.loads(r)['result'][db_type])[:limit] results = [i.get('imdbnumber') for i in r] Movies(results, 'imdb_id').worker() except: pass else: from indexers.tvshows import build_episode from modules.indicators_bookmarks import get_watched_info_tv from tikimeta import tvshow_meta, retrieve_user_info from threading import Thread def process_eps(item): results.append( build_episode( { "season": int(item['season']), "episode": int(item['episode']), 'order': item['order'], "meta": tvshow_meta('tvdb_id', item['media_id'], meta_user_info) }, watched_info, use_trakt, meta_user_info)) try: db_type = 'episodes' view_type = 'view.episodes' ALL_JSON_req = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetTvShows", \ "params": {"properties": ["imdbnumber","uniqueid"]}, "id": "1"}' r = xbmc.executeJSONRPC(ALL_JSON_req) r = to_utf8(json.loads(r)['result']['tvshows']) tvshow_list = [{ 'tvshow_id': i["tvshowid"], 'media_id': i['uniqueid']['tvdb'] if 'uniqueid' in i and 'tvdb' in i['uniqueid'] else i['imdbnumber'] if not i['imdbnumber'].startswith("tt") else None } for i in r] tvshow_list = [i for i in tvshow_list if i['media_id'] != None] JSON_req = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetRecentlyAddedEpisodes", \ "params": {"properties": ["tvshowid", "season", "episode"]}, "id": "1"}' r = xbmc.executeJSONRPC(JSON_req) r = to_utf8(json.loads(r)['result'][db_type])[:limit] episodes_list = [{ 'tvshow_id': i['tvshowid'], 'season': i['season'], 'episode': i['episode'], 'order': r.index(i) } for i in r] watched_info, use_trakt = get_watched_info_tv() meta_user_info = retrieve_user_info() window.setProperty('fen_fanart_error', 'true') for i in episodes_list: for t in tvshow_list: if i['tvshow_id'] == t['tvshow_id']: recent_added.append({ 'media_id': t['media_id'], 'season': i['season'], 'episode': i['episode'], 'order': episodes_list.index(i) }) threads = [] for item in recent_added: threads.append(Thread(target=process_eps, args=(item, ))) [i.start() for i in threads] [i.join() for i in threads] r = [i for i in results if i is not None] r = sorted(r, key=lambda k: k['order']) listitems = [i['listitem'] for i in r] xbmcplugin.addDirectoryItems(__handle__, listitems, len(listitems)) except: pass xbmcplugin.setContent(__handle__, db_type) xbmcplugin.endOfDirectory(__handle__) setView(view_type)