def imdb_build_keyword_results(db_type, query):
def _builder():
for count, item in enumerate(results, 1):
cm = []
cm_append = cm.append
keyword = item[0]
listings = item[1]
url_params = {'mode': mode, 'action': 'imdb_keywords_list_contents', 'list_id': keyword.lower(), 'iconImage': 'imdb.png'}
url_json = json.dumps(url_params)
add_list_params = {'mode': 'navigator.adjust_main_lists', 'method': 'add_external', 'list_name': '%s (IMDb)' % keyword, 'menu_item': url_json}
add_folder_params = {'mode': 'navigator.adjust_shortcut_folder_lists', 'method': 'add_external', 'name': '%s (IMDb)' % keyword, 'menu_item': url_json}
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel('%02d | [B]%s[/B] [I]%s[/I]' % (count, keyword.upper(), listings))
listitem.setArt({'icon': default_imdb_icon, 'poster': default_imdb_icon, 'thumb': default_imdb_icon, 'fanart': fanart, 'banner': default_imdb_icon})
cm_append((ls(32730),'RunPlugin(%s)' % build_url(add_list_params)))
cm_append((ls(32731),'RunPlugin(%s)' % build_url(add_folder_params)))
listitem.addContextMenuItems(cm)
yield (url, listitem, True)
__handle__ = int(argv[1])
results = imdb_keyword_search(query)
add_to_search_history(query, 'imdb_keyword_%s_queries' % db_type)
if not results: return
mode = 'build_%s_list' % db_type
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.main')
def search_furk(params):
from modules.history import add_to_search_history
__handle__ = int(argv[1])
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 = kodi_utils.dialog.input('Fen')
try:
search_name = clean_file_name(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 kodi_utils.ok_dialog(text=32760, top_space=True)
try:
files = [
i for i in files
if i.get('is_ready', '0') == '1' and i['type'] == list_type
]
except:
return kodi_utils.ok_dialog(text=32760, top_space=True)
furk_file_browser(files, params, 'search', __handle__)
except:
pass
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def build_trakt_list(params):
def _process_ids(item_position, item):
item['media_id'] = trakt_api.get_trakt_movie_id(item['media_ids']) if item['media_type'] == 'movie' else trakt_api.get_trakt_tvshow_id(item['media_ids'])
final_append((item_position, item))
def _add_misc_dir(url_params, list_name=ls(32799), iconImage='item_next.png', isFolder=True):
icon = kodi_utils.translate_path('special://home/addons/script.tikiart/resources/media/%s' % iconImage)
listitem = make_listitem()
listitem.setLabel(list_name)
listitem.setArt({'icon': icon, 'poster': icon, 'thumb': icon, 'fanart': fanart, 'banner': icon})
if url_params['mode'] == 'build_navigate_to_page':
listitem.setProperty('SpecialSort', 'top')
listitem.addContextMenuItems([(ls(32784),'RunPlugin(%s)' % build_url({'mode': 'toggle_jump_to'}))])
else:
listitem.setProperty('SpecialSort', 'bottom')
kodi_utils.add_item(__handle__, build_url(url_params), listitem, isFolder)
__handle__ = int(argv[1])
is_widget = kodi_utils.external_browse()
user, slug, list_type = params.get('user'), params.get('slug'), params.get('list_type')
letter, page_no = params.get('new_letter', 'None'), int(params.get('new_page', '1'))
original_list, final_list, final_listitems = [], [], []
original_append, final_append = original_list.append, final_list.append
result = trakt_api.get_trakt_list_contents(list_type, user, slug)
for item in result:
try:
media_type = item['type']
if not media_type in ('movie', 'show'): continue
original_append({'media_type': media_type, 'title': item[media_type]['title'], 'media_ids': item[media_type]['ids']})
except: pass
if paginate():
limit = page_limit()
trakt_list, total_pages = paginate_list(original_list, page_no, letter, limit)
else:
trakt_list, total_pages = original_list, 1
threads = list(make_thread_list_enumerate(_process_ids, trakt_list, Thread))
[i.join() for i in threads]
final_list.sort(key=lambda k: k[0])
final_list = [i[1] for i in final_list]
movie_list = [(i['media_id'], final_list.index(i), 'movie') for i in final_list if i['media_type'] == 'movie']
tvshow_list = [(i['media_id'], final_list.index(i), 'tvshow') for i in final_list if i['media_type'] == 'show']
content = 'movies' if len(movie_list) > len(tvshow_list) else 'tvshows'
if total_pages > 2 and not is_widget:
_add_misc_dir({'mode': 'build_navigate_to_page', 'db_type': 'Media', 'user': user, 'slug': slug, 'current_page': page_no, 'total_pages': total_pages,
'transfer_mode': 'trakt.list.build_trakt_list'}, ls(32964), 'item_jump.png', False)
if len(movie_list) > 0:
movie_listitems = Movies({'list': [i[0] for i in movie_list]}).worker()
final_listitems.extend([(i, x[1]) for i in movie_listitems for x in movie_list if [str(x[0]) == i[1].getUniqueID('tmdb') and x[2] == 'movie'][0]])
if len(tvshow_list) > 0:
tvshow_listitems = TVShows({'list': [i[0] for i in tvshow_list]}).worker()
final_listitems.extend([(i, x[1]) for i in tvshow_listitems for x in tvshow_list if [str(x[0]) == i[1].getUniqueID('tmdb') and x[2] == 'tvshow'][0]])
final_listitems.sort(key=lambda k: k[1])
item_list = [i[0] for i in final_listitems]
kodi_utils.add_items(__handle__, item_list)
if total_pages > page_no: _add_misc_dir({'mode': 'trakt.list.build_trakt_list', 'user': user, 'slug': slug, 'new_page': str(page_no + 1), 'new_letter': letter})
kodi_utils.set_content(__handle__, content)
kodi_utils.end_directory(__handle__)
if params.get('refreshed'): kodi_utils.sleep(1500)
kodi_utils.set_view_mode('view.trakt_list', content)
def browse_ad_cloud(folder):
def _builder():
for count, item in enumerate(links, 1):
try:
cm = []
url_link = item['link']
name = clean_file_name(item['filename']).upper()
size = item['size']
display_size = float(int(size)) / 1073741824
display = '%02d | [B]%s[/B] | %.2f GB | [I]%s [/I]' % (
count, file_str, display_size, name)
url_params = {
'mode': 'alldebrid.resolve_ad',
'url': url_link,
'play': 'true'
}
url = build_url(url_params)
down_file_params = {
'mode': 'downloader',
'name': name,
'url': url_link,
'action': 'cloud.alldebrid',
'image': default_ad_icon
}
cm.append(
(down_str, 'RunPlugin(%s)' % build_url(down_file_params)))
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_ad_icon,
'poster': default_ad_icon,
'thumb': default_ad_icon,
'fanart': fanart,
'banner': default_ad_icon
})
listitem.setInfo('video', {})
yield (url, listitem, False)
except:
pass
__handle__ = int(argv[1])
file_str, down_str = ls(32743).upper(), ls(32747)
extensions = supported_video_extensions()
links = json.loads(folder)
links = [
i for i in links if i['filename'].lower().endswith(tuple(extensions))
]
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def my_furk_files(params):
__handle__ = int(argv[1])
try:
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, 'file_browse', __handle__)
except:
pass
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def furk_tfile_video(params):
def _builder():
for count, item in enumerate(t_files, 1):
try:
cm = []
url_params = {
'mode': 'media_play',
'url': item['url_dl'],
'media_type': 'video'
}
url = build_url(url_params)
name = clean_file_name(item['name']).upper()
height = int(item['height'])
if 1200 < height > 2100: display_res = '4K'
elif 1000 < height < 1200: display_res = '1080P'
elif 680 < height < 1000: display_res = '720P'
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 = make_listitem()
listitem.setLabel(display_name)
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': item['url_dl'],
'action': 'cloud.furk_direct',
'image': default_furk_icon
}
cm.append(
(ls(32747), '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
})
yield (url, listitem, False)
except:
pass
__handle__ = int(argv[1])
t_files = [
i for i in Furk.t_files(params.get('item_id'))
if 'video' in i['ct'] and 'bitrate' in i
]
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def furk_tfile_audio(params):
__handle__ = int(argv[1])
kodi_utils.clear_property('furk_t_files_json')
excludes = ('', 'cover', 'covers', 'scan', 'scans', 'playlists')
t_files = Furk.t_files(params.get('item_id'))
item_path_list = list(
set([
clean_file_name(i['path']) for i in t_files
if clean_file_name(i['path']).lower() not in excludes
]))
item_path_list.sort()
line = '%s[CR]%s[CR]%s'
if not item_path_list:
if kodi_utils.confirm_dialog(text=32763,
ok_label=32652,
cancel_label=32764,
top_space=True):
return browse_audio_album(t_files, params.get('name'))
from modules.player import FenPlayer
FenPlayer().playAudioAlbum(t_files)
return browse_audio_album(t_files, __handle__)
def _builder():
for x in item_path_list:
try:
url_params = {
'mode': 'furk.browse_audio_album',
'item_path': x,
'handle': __handle__
}
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(x.upper())
listitem.setArt({
'icon': default_furk_icon,
'poster': default_furk_icon,
'thumb': default_furk_icon,
'fanart': fanart,
'banner': default_furk_icon
})
yield (url, listitem, True)
except:
pass
t_files_json = json.dumps(t_files)
kodi_utils.set_property('furk_t_files_json', str(t_files_json))
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def search_trakt_lists(params):
def _builder():
for item in lists:
try:
list_key = item['type']
if list_key == 'officiallist': continue
list_info = item[list_key]
name = list_info['name']
user = list_info['username']
slug = list_info['ids']['slug']
item_count = list_info['item_count']
if list_info['privacy'] == 'private' or item_count == 0: continue
cm = []
cm_append = cm.append
url_params = {'mode': 'trakt.list.build_trakt_list', 'user': user, 'slug': slug}
trakt_selection_url = {'mode': 'navigator.adjust_main_lists', 'method': 'add_trakt_external', 'name': name, 'user': user, 'slug': slug}
trakt_folder_selection_url = {'mode': 'navigator.adjust_shortcut_folder_lists', 'method': 'add_trakt_external', 'name': name, 'user': user, 'slug': slug}
like_list_url = {'mode': 'trakt.trakt_like_a_list', 'user': user, 'list_slug': slug}
unlike_list_url = {'mode': 'trakt.trakt_unlike_a_list', 'user': user, 'list_slug': slug}
url = build_url(url_params)
cm_append((ls(32730),'RunPlugin(%s)' % build_url(trakt_selection_url)))
cm_append((ls(32731),'RunPlugin(%s)' % build_url(trakt_folder_selection_url)))
cm_append((ls(32776),'RunPlugin(%s)' % build_url(like_list_url)))
cm_append((ls(32783),'RunPlugin(%s)' % build_url(unlike_list_url)))
display = '[B]%s[/B] | [I]%s (x%s)[/I]' % (name.upper(), user, str(item_count))
listitem = make_listitem()
listitem.setLabel(display)
listitem.setArt({'icon': trakt_icon, 'poster': trakt_icon, 'thumb': trakt_icon, 'fanart': fanart, 'banner': trakt_icon})
listitem.addContextMenuItems(cm)
yield (url, listitem, True)
except: pass
__handle__ = int(argv[1])
mode = params.get('mode')
page = params.get('new_page', '1')
search_title = params.get('search_title', None) or kodi_utils.dialog.input('Fen')
if not search_title: return
lists, pages = trakt_api.trakt_search_lists(search_title, page)
kodi_utils.add_items(__handle__, list(_builder()))
if pages > page: kodi_utils.add_dir({'mode': mode, 'search_title': search_title, 'new_page': str(int(page) + 1)}, ls(32799), __handle__, iconImage='item_next.png')
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.main')
def search_easynews(params):
from modules.history import add_to_search_history
__handle__ = int(argv[1])
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 = kodi_utils.dialog.input('Enter search Term')
try:
if search_title:
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 kodi_utils.ok_dialog(text=32760, top_space=True)
easynews_file_browser(files, __handle__)
except:
pass
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def imdb_build_user_lists(db_type):
def _builder():
for item in user_lists:
cm = []
cm_append = cm.append
url_params = {'mode': mode, 'action': 'imdb_user_list_contents', 'list_id': item['list_id']}
imdb_selection_url = {'mode': 'navigator.adjust_main_lists', 'method': 'add_imdb_external', 'name': item['title'], 'imdb_params': json.dumps(url_params)}
imdb_folder_selection_url = {'mode': 'navigator.adjust_shortcut_folder_lists', 'method': 'add_imdb_external', 'name': item['title'], 'imdb_params': json.dumps(url_params)}
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(item['title'])
listitem.setArt({'icon': default_imdb_icon, 'poster': default_imdb_icon, 'thumb': default_imdb_icon, 'fanart': fanart, 'banner': default_imdb_icon})
cm_append((ls(32730),'RunPlugin(%s)' % build_url(imdb_selection_url)))
cm_append((ls(32731),'RunPlugin(%s)' % build_url(imdb_folder_selection_url)))
listitem.addContextMenuItems(cm)
yield (url, listitem, True)
__handle__ = int(argv[1])
user_lists = imdb_user_lists(db_type)
mode = 'build_%s_list' % db_type
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.main')
def get_trakt_trending_popular_lists(params):
def _process():
for item in lists:
try:
cm = []
cm_append = cm.append
_item = item['list']
name = _item['name']
user = _item['user']['ids']['slug']
slug = _item['ids']['slug']
item_count = _item.get('item_count', None)
if item_count: display_name = '%s (x%s) - [I] %s[/I]' % (name, item_count, user)
else: display_name = '%s - [I] %s[/I]' % (name, user)
url_params = {'mode': 'trakt.list.build_trakt_list', 'user': user, 'slug': slug, 'list_type': 'user_lists'}
trakt_selection_url = {'mode': 'navigator.adjust_main_lists', 'method': 'add_trakt_external', 'name': name, 'user': user, 'slug': slug}
trakt_folder_selection_url = {'mode': 'navigator.adjust_shortcut_folder_lists', 'method': 'add_trakt_external', 'name': name, 'user': user, 'slug': slug}
like_list_url = {'mode': 'trakt.trakt_like_a_list', 'user': user, 'list_slug': slug}
unlike_list_url = {'mode': 'trakt.trakt_unlike_a_list', 'user': user, 'list_slug': slug}
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(display_name)
listitem.setArt({'icon': trakt_icon, 'poster': trakt_icon, 'thumb': trakt_icon, 'fanart': fanart, 'banner': trakt_icon})
cm_append((ls(32730),'RunPlugin(%s)' % build_url(trakt_selection_url)))
cm_append((ls(32731),'RunPlugin(%s)' % build_url(trakt_folder_selection_url)))
cm_append((ls(32776),'RunPlugin(%s)' % build_url(like_list_url)))
cm_append((ls(32783),'RunPlugin(%s)' % build_url(unlike_list_url)))
listitem.addContextMenuItems(cm)
yield (url, listitem, True)
except: pass
__handle__ = int(argv[1])
list_type = params['list_type']
lists = trakt_api.trakt_trending_popular_lists(list_type)
kodi_utils.add_items(__handle__, list(_process()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.main')
def pm_transfers():
def _builder():
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(r'\.{0,1}(\d+)',
str(progress))[0][:2]
except:
progress = ''
if file_type == 'folder':
is_folder = True if status == 'finished' else False
display = '%02d | %s%% | [B]%s[/B] | [I]%s [/I]' % (
count, str(progress), folder_str, name)
url_params = {
'mode': 'premiumize.pm_torrent_cloud',
'id': item['folder_id'],
'folder_name': normalize(item['name'])
}
else:
is_folder = False
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_str, display_size, name)
url_params = {
'mode': 'media_play',
'url': url_link,
'media_type': 'video'
}
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': url_link,
'db_type': 'cloud.premiumize',
'image': default_pm_icon
}
cm.append((down_str,
'RunPlugin(%s)' % build_url(down_file_params)))
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_pm_icon,
'poster': default_pm_icon,
'thumb': default_pm_icon,
'fanart': fanart,
'banner': default_pm_icon
})
yield (url, listitem, is_folder)
except:
pass
__handle__ = int(argv[1])
extensions = supported_video_extensions()
transfer_files = Premiumize.transfers_list()['transfers']
folder_str, file_str, down_str = ls(32742).upper(), ls(32743).upper(), ls(
32747)
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def build_episode_list(params):
def _process():
for item in episodes_data:
try:
cm = []
listitem = make_listitem()
set_property = listitem.setProperty
cm_append = cm.append
item_get = item.get
season = item_get('season')
episode = item_get('episode')
ep_name = item_get('title')
premiered = item_get('premiered')
all_cast = cast + item_get('guest_stars', [])
episode_date, premiered = adjust_premiered_date(premiered, adjust_hours)
playcount, overlay = get_watched_status(watched_info, string(tmdb_id), season, episode)
resumetime = get_resumetime(bookmarks, tmdb_id, season, episode)
thumb = item_get('thumb', None) or fanart
if thumb_fanart: background = thumb
else: background = fanart
item.update({'trailer': trailer, 'tvshowtitle': title, 'premiered': premiered, 'genre': genre, 'duration': duration, 'mpaa': mpaa, 'studio': studio,
'playcount': playcount, 'overlay': overlay})
extras_params = build_url({'mode': 'extras_menu_choice', 'tmdb_id': tmdb_id, 'db_type': 'tvshow', 'is_widget': is_widget})
options_params = build_url({'mode': 'options_menu_choice', 'content': 'episode', 'tmdb_id': tmdb_id, 'season': season, 'episode': episode})
url_params = build_url({'mode': 'play_media', 'vid_type': 'episode', 'tmdb_id': tmdb_id, 'season': season, 'episode': episode})
display = ep_name
unaired = False
if not episode_date or current_date < episode_date:
if not show_unaired: continue
if season != 0:
unaired = True
display = unaired_label % ep_name
item['title'] = display
cm_append((extras_str, run_plugin % extras_params))
cm_append((options_str, run_plugin % options_params))
clearprog_params, unwatched_params, watched_params = '', '', ''
if not unaired:
if resumetime != '0':
clearprog_params = build_url({'mode': 'watched_unwatched_erase_bookmark', 'db_type': 'episode', 'tmdb_id': tmdb_id,
'season': season, 'episode': episode, 'refresh': 'true'})
cm_append((clearprog_str, run_plugin % clearprog_params))
set_property('fen_in_progress', 'true')
if playcount:
unwatched_params = build_url({'mode': 'mark_as_watched_unwatched_episode', 'action': 'mark_as_unwatched', 'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id, 'season': season, 'episode': episode, 'title': title, 'year': year})
cm_append((unwatched_str % watched_title, run_plugin % unwatched_params))
else:
watched_params = build_url({'mode': 'mark_as_watched_unwatched_episode', 'action': 'mark_as_watched', 'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id, 'season': season, 'episode': episode, 'title': title, 'year': year})
cm_append((watched_str % watched_title, run_plugin % watched_params))
listitem.setLabel(display)
listitem.setContentLookup(False)
listitem.addContextMenuItems(cm)
listitem.setArt({'poster': show_poster, 'fanart': background, 'thumb': thumb, 'icon':thumb, 'banner': banner, 'clearart': clearart, 'clearlogo': clearlogo,
'landscape': thumb, 'tvshow.clearart': clearart, 'tvshow.clearlogo': clearlogo, 'tvshow.landscape': thumb, 'tvshow.banner': banner})
listitem.setCast(all_cast)
listitem.setUniqueIDs({'imdb': imdb_id, 'tmdb': string(tmdb_id), 'tvdb': string(tvdb_id)})
listitem.setInfo('video', remove_meta_keys(item, dict_removals))
set_property('resumetime', resumetime)
if is_widget:
set_property('fen_widget', 'true')
set_property('fen_playcount', string(playcount))
set_property('fen_options_menu_params', options_params)
set_property('fen_extras_menu_params', extras_params)
set_property('fen_unwatched_params', unwatched_params)
set_property('fen_watched_params', watched_params)
set_property('fen_clearprog_params', clearprog_params)
else: set_property('fen_widget', 'false')
yield (url_params, listitem, False)
except: pass
__handle__ = int(argv[1])
item_list = []
append = item_list.append
meta_user_info, watched_indicators, watched_info, show_unaired, thumb_fanart, is_widget, current_date, adjust_hours, bookmarks = get_episode_info()
poster_main, poster_backup, fanart_main, fanart_backup = settings.get_art_provider()
all_episodes = True if params.get('season') == 'all' else False
meta = metadata.tvshow_meta('tmdb_id', params.get('tmdb_id'), meta_user_info)
meta_get = meta.get
tmdb_id, tvdb_id, imdb_id = meta_get('tmdb_id'), meta_get('tvdb_id'), meta_get('imdb_id')
title, year, rootname, banner = meta_get('title'), meta_get('year'), meta_get('rootname'), meta_get('banner')
show_poster = meta_get(poster_main) or meta_get(poster_backup) or poster_empty
fanart = meta_get(fanart_main) or meta_get(fanart_backup) or fanart_empty
clearlogo, clearart, landscape = meta_get('clearlogo'), meta_get('clearart'), meta_get('landscape')
cast, mpaa, duration = meta_get('cast'), meta_get('mpaa'), meta_get('duration')
trailer, genre, studio = string(meta_get('trailer')), meta_get('genre'), meta_get('studio')
tvshow_plot = meta_get('plot')
get_resumetime = indicators.get_resumetime
get_watched_status = indicators.get_watched_status_episode
watched_title = 'Trakt' if watched_indicators == 1 else 'Fen'
if all_episodes:
episodes_data = metadata.all_episodes_meta(meta, meta_user_info)
if not settings.show_specials(): episodes_data = [i for i in episodes_data if not i['season'] == 0]
else: episodes_data = metadata.season_episodes_meta(params['season'], meta, meta_user_info)
kodi_utils.add_items(__handle__, list(_process()))
kodi_utils.set_content(__handle__, 'episodes')
kodi_utils.set_sort_method(__handle__, 'episodes')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.episodes', 'episodes')
def build_single_episode(list_type, data):
def _sort_results(items):
if list_type_starts_with('next_episode'):
def func(function):
if sort_key == 'fen_name': return title_key(function, ignore_articles)
elif sort_key == 'fen_last_played': return jsondate_to_datetime(function, resformat)
else: return function
sort_key = nextep_settings['sort_key']
sort_direction = nextep_settings['sort_direction']
if nextep_settings['sort_airing_today_to_top']:
airing_today = [i for i in items if date_difference(current_date, jsondate_to_datetime(i[1].getProperty('fen_first_aired'), '%Y-%m-%d').date(), 0)]
airing_today = sorted(airing_today, key=lambda i: i[1].getProperty('fen_first_aired'))
remainder = [i for i in items if not i in airing_today]
remainder = sorted(remainder, key=lambda i: func(i[1].getProperty(sort_key)), reverse=sort_direction)
unaired = [i for i in remainder if i[1].getProperty('fen_unaired') == 'true']
aired = [i for i in remainder if not i in unaired]
remainder = aired + unaired
items = airing_today + remainder
else:
items = sorted(items, key=lambda i: func(i[1].getProperty(sort_key)), reverse=sort_direction)
unaired = [i for i in items if i[1].getProperty('fen_unaired') == 'true']
aired = [i for i in items if not i in unaired]
items = aired + unaired
else: items.sort(key=lambda k: int(k[1].getProperty('fen_sort_order')))
return items
def _process(item_position, ep_data):
try:
cm = []
listitem = make_listitem()
set_property = listitem.setProperty
cm_append = cm.append
ep_data_get = ep_data.get
if list_type_starts_with('trakt_'): tmdb_id = get_trakt_tvshow_id(ep_data_get('ids'))
else: tmdb_id = ep_data_get('tmdb_id')
if not tmdb_id: return
meta = metadata.tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
meta_get = meta.get
tmdb_id, tvdb_id, imdb_id = meta_get('tmdb_id'), meta_get('tvdb_id'), meta_get('imdb_id')
title, year, rootname, banner = meta_get('title'), meta_get('year'), meta_get('rootname'), meta_get('banner')
show_poster = meta_get(poster_main) or meta_get(poster_backup) or poster_empty
fanart = meta_get(fanart_main) or meta_get(fanart_backup) or fanart_empty
clearlogo, clearart, landscape = meta_get('clearlogo'), meta_get('clearart'), meta_get('landscape')
cast, mpaa, duration = meta_get('cast'), meta_get('mpaa'), meta_get('duration')
trailer, genre, studio = string(meta_get('trailer')), meta_get('genre'), meta_get('studio')
tvshow_plot = meta_get('plot')
orig_season = ep_data_get('season')
orig_episode = ep_data_get('episode')
if list_type_starts_with('next_episode'):
season_data = meta_get('season_data')
curr_season_data = [i for i in season_data if i['season_number'] == orig_season][0]
orig_season = orig_season if orig_episode < curr_season_data['episode_count'] else orig_season + 1
orig_episode = orig_episode + 1 if orig_episode < curr_season_data['episode_count'] else 1
episodes_data = metadata.season_episodes_meta(orig_season, meta, meta_user_info)
try: item = [i for i in episodes_data if i['episode'] == orig_episode][0]
except: return
item_get = item.get
season = item_get('season')
episode = item_get('episode')
ep_name = item_get('title')
orig_premiered = item_get('premiered')
all_cast = cast + item_get('guest_stars', [])
episode_date, premiered = adjust_premiered_date(orig_premiered, adjust_hours)
if not episode_date or current_date < episode_date:
if list_type_starts_with('next_episode'):
if not include_unaired: return
if not date_difference(current_date, episode_date, 7): return
elif not show_unaired: return
unaired = True
set_property('fen_unaired', 'true')
else:
unaired = False
set_property('fen_unaired', 'false')
playcount, overlay = get_watched_status(watched_info, string(tmdb_id), season, episode)
resumetime = get_resumetime(bookmarks, tmdb_id, season, episode)
if display_title == 0: title_string = '%s: ' % title
else: title_string = ''
if display_title in (0,1): seas_ep = '%dx%.2d - ' % (season, episode)
else: seas_ep = ''
if list_type_starts_with('next_episode'):
unwatched = ep_data_get('unwatched', False)
if episode_date: display_premiered = make_day(current_date, episode_date, date_format)
else: display_premiered == 'UNKNOWN'
airdate = '[[COLOR magenta]%s[/COLOR]] ' % display_premiered if include_airdate else ''
highlight_color = unwatched_color if unwatched else unaired_color if unaired else ''
italics_open, italics_close = ('[I]', '[/I]') if highlight_color else ('', '')
if highlight_color: episode_info = '%s[COLOR %s]%s %s[/COLOR]%s' % (italics_open, highlight_color, seas_ep, ep_name, italics_close)
else: episode_info = '%s%s%s%s' % (italics_open, seas_ep, ep_name, italics_close)
display = '%s%s%s' % (airdate, upper(title_string), episode_info)
elif list_type == 'trakt_calendar':
if episode_date: display_premiered = make_day(current_date, episode_date, date_format)
else: display_premiered == 'UNKNOWN'
display = '[%s]%s%s%s' % (display_premiered, upper(title_string), seas_ep, item_get('title'))
if unaired:
displays = display.split(']')
display = '[COLOR red]' + displays[0] + '][/COLOR]' + displays[1]
else:
color_tags = ('[COLOR red]', '[/COLOR]') if unaired else ('', '')
display = '%s%s%s%s%s' % (upper(title_string), color_tags[0], seas_ep, ep_name, color_tags[1])
thumb = item_get('thumb', None) or fanart
if thumb_fanart: background = thumb
else: background = fanart
item.update({'trailer': trailer, 'tvshowtitle': title, 'premiered': premiered, 'genre': genre, 'duration': duration,
'mpaa': mpaa, 'studio': studio, 'playcount': playcount, 'overlay': overlay, 'title': display})
extras_params = build_url({'mode': 'extras_menu_choice', 'tmdb_id': tmdb_id, 'db_type': 'tvshow', 'is_widget': is_widget})
options_params = build_url({'mode': 'options_menu_choice', 'content': 'episode', 'tmdb_id': tmdb_id, 'season': season, 'episode': episode})
url_params = build_url({'mode': 'play_media', 'vid_type': 'episode', 'tmdb_id': tmdb_id, 'season': season, 'episode': episode})
if show_all_episodes:
if all_episodes == 1 and meta_get('total_seasons') > 1: browse_params = build_url({'mode': 'build_season_list', 'tmdb_id': tmdb_id})
else: browse_params = build_url({'mode': 'build_episode_list', 'tmdb_id': tmdb_id, 'season': 'all'})
else: browse_params = build_url({'mode': 'build_season_list', 'tmdb_id': tmdb_id})
cm_append((extras_str, run_plugin % extras_params))
cm_append((options_str, run_plugin % options_params))
cm_append((browse_str, container_update % browse_params))
clearprog_params, unwatched_params, watched_params = '', '', ''
if not unaired:
if resumetime != '0':
clearprog_params = build_url({'mode': 'watched_unwatched_erase_bookmark', 'db_type': 'episode', 'tmdb_id': tmdb_id,
'season': season, 'episode': episode, 'refresh': 'true'})
cm_append((clearprog_str, run_plugin % clearprog_params))
set_property('fen_in_progress', 'true')
if playcount:
unwatched_params = build_url({'mode': 'mark_as_watched_unwatched_episode', 'action': 'mark_as_unwatched', 'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id, 'season': season, 'episode': episode, 'title': title, 'year': year})
cm_append((unwatched_str % watched_title, run_plugin % unwatched_params))
else:
watched_params = build_url({'mode': 'mark_as_watched_unwatched_episode', 'action': 'mark_as_watched', 'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id, 'season': season, 'episode': episode, 'title': title, 'year': year})
cm_append((watched_str % watched_title, run_plugin % watched_params))
if list_type == 'next_episode_trakt': cm_append((ls(32599), container_update % build_url({'mode': 'build_next_episode_manager'})))
listitem.setLabel(display)
listitem.setContentLookup(False)
listitem.addContextMenuItems(cm)
listitem.setArt({'poster': show_poster, 'fanart': background, 'thumb': thumb, 'icon':thumb, 'banner': banner, 'clearart': clearart, 'clearlogo': clearlogo,
'landscape': thumb, 'tvshow.clearart': clearart, 'tvshow.clearlogo': clearlogo, 'tvshow.landscape': thumb, 'tvshow.banner': banner})
listitem.setCast(all_cast)
listitem.setUniqueIDs({'imdb': imdb_id, 'tmdb': string(tmdb_id), 'tvdb': string(tvdb_id)})
listitem.setInfo('video', remove_meta_keys(item, dict_removals))
set_property('resumetime', resumetime)
set_property('fen_name', '%s - %.2dx%.2d' % (title, season, episode))
if list_type_starts_with('next_episode'):
last_played = ep_data_get('last_played', resinsert)
set_property('fen_last_played', last_played)
set_property('fen_first_aired', premiered)
else: set_property('fen_sort_order', string(item_position))
if is_widget:
set_property('fen_widget', 'true')
set_property('fen_playcount', string(playcount))
set_property('fen_browse_params', browse_params)
set_property('fen_options_menu_params', options_params)
set_property('fen_extras_menu_params', extras_params)
set_property('fen_unwatched_params', unwatched_params)
set_property('fen_watched_params', watched_params)
set_property('fen_clearprog_params', clearprog_params)
else: set_property('fen_widget', 'false')
append((url_params, listitem, False))
except: pass
__handle__ = int(argv[1])
item_list = []
append = item_list.append
list_type_starts_with = list_type.startswith
get_resumetime = indicators.get_resumetime
get_watched_status = indicators.get_watched_status_episode
meta_user_info, watched_indicators, watched_info, show_unaired, thumb_fanart, is_widget, current_date, adjust_hours, bookmarks = get_episode_info()
display_title, date_format, art_keys, all_episodes = get_single_episode_info()
show_all_episodes = all_episodes in (1, 2)
poster_main, poster_backup, fanart_main, fanart_backup = settings.get_art_provider()
ignore_articles = settings.ignore_articles()
watched_title = 'Trakt' if watched_indicators == 1 else 'Fen'
if list_type_starts_with('next_episode'):
nextep_settings, nextep_display_settings = settings.nextep_content_settings(), settings.nextep_display_settings()
unaired_color, unwatched_color = nextep_display_settings['unaired_color'], nextep_display_settings['unwatched_color']
include_airdate = nextep_display_settings['include_airdate']
include_unaired = nextep_settings['include_unaired']
if watched_indicators == 1: resformat, resinsert = '%Y-%m-%dT%H:%M:%S.%fZ', '2000-01-01T00:00:00.000Z'
else: resformat, resinsert = '%Y-%m-%d %H:%M:%S', '2000-01-01 00:00:00'
threads = list(make_thread_list_enumerate(_process, data, Thread))
[i.join() for i in threads]
item_list = _sort_results(item_list)
kodi_utils.add_items(__handle__, item_list)
kodi_utils.set_content(__handle__, 'episodes')
kodi_utils.end_directory(__handle__, cacheToDisc=False)
kodi_utils.set_view_mode('view.episodes', 'episodes')
if list_type == 'trakt_calendar' and settings.calendar_focus_today():
today = '[%s]' % ls(32849).upper()
try: index = max([i for i, x in enumerate([i[1].getLabel() for i in item_list]) if today in x])
except: return
kodi_utils.focus_index(index)
def fetch_list(self):
try:
params_get = self.params.get
self.is_widget = kodi_utils.external_browse()
self.exit_list_params = params_get(
'exit_list_params',
None) or kodi_utils.get_infolabel('Container.FolderPath')
self.handle = int(argv[1])
content_type = 'tvshows'
mode = params_get('mode')
try:
page_no = int(params_get('new_page', '1'))
except ValueError:
page_no = params_get('new_page')
letter = params_get('new_letter', 'None')
list_append = self.list.append
if self.action in personal:
if self.action == 'favourites_tvshows':
var_module, import_function = 'modules.favourites', 'retrieve_favourites'
elif self.action == 'in_progress_tvshows':
var_module, import_function = 'modules.watched_status', 'get_in_progress_tvshows'
else:
var_module, import_function = 'modules.watched_status', 'get_watched_items'
else:
var_module, import_function = 'apis.%s_api' % self.action.split(
'_')[0], self.action
try:
function = manual_function_import(var_module, import_function)
except:
pass
if self.action in tmdb_main:
data = function(page_no)
for item in data['results']:
list_append(item['id'])
self.new_page = {
'new_page':
string(
(data['page'] if 'tmdb' in self.action else page_no) +
1)
}
elif self.action in trakt_main:
data = function(page_no)
for item in data:
list_append(get_trakt_tvshow_id(item['show']['ids']))
self.new_page = {
'new_page':
string(
(data['page'] if 'tmdb' in self.action else page_no) +
1)
}
elif self.action in trakt_personal:
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
try:
if total_pages > page_no:
self.new_page = {
'new_page': string(page_no + 1),
'new_letter': letter
}
except:
pass
elif self.action in imdb_personal:
self.id_type = 'imdb_id'
list_id = params_get('list_id', None)
data, next_page = function('tvshow', list_id, page_no)
self.list = [i['imdb_id'] for i in data]
if next_page:
self.new_page = {
'list_id': list_id,
'new_page': string(page_no + 1),
'new_letter': letter
}
elif self.action in personal:
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 = {
'new_page': string(page_no + 1),
'new_letter': letter
}
elif self.action in similar:
tmdb_id = self.params['tmdb_id']
data = function(tmdb_id, page_no)
self.list = [i['id'] for i in data['results']]
if data['page'] < data['total_pages']:
self.new_page = {
'new_page': string(data['page'] + 1),
'tmdb_id': tmdb_id
}
elif self.action in tmdb_special:
key = tmdb_special_key_dict[self.action]
function_var = params_get(key, None)
if not function_var: return
data = function(function_var, page_no)
self.list = [i['id'] for i in data['results']]
if data['page'] < data['total_pages']:
self.new_page = {
'new_page': string(data['page'] + 1),
key: function_var
}
elif self.action == 'tmdb_tv_discover':
from indexers.discover import set_history
name = self.params['name']
query = self.params['query']
if page_no == 1: set_history('tvshow', name, query)
data = function(query, page_no)
for item in data['results']:
list_append(item['id'])
if data['page'] < data['total_pages']:
self.new_page = {
'query': query,
'name': name,
'new_page': string(data['page'] + 1)
}
elif self.action == 'trakt_tv_mosts':
for item in function(self.params['period'],
self.params['duration'], page_no):
list_append((get_trakt_tvshow_id(item['show']['ids'])))
self.new_page = {
'period': self.params['period'],
'duration': self.params['duration'],
'new_page': string(page_no + 1)
}
elif self.action == 'trakt_tv_related':
imdb_id = params_get('imdb_id')
data, total_pages = function(imdb_id, page_no)
for item in data:
list_append(get_trakt_tvshow_id(item['ids']))
if total_pages > page_no:
self.new_page = {
'new_page': string(page_no + 1),
'imdb_id': imdb_id,
'imdb_id': params_get('imdb_id')
}
elif self.action == 'tmdb_tv_genres':
genre_id = self.params[
'genre_id'] if 'genre_id' in self.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 = {
'new_page': string(data['page'] + 1),
'genre_id': genre_id
}
elif self.action == 'trakt_tv_certifications':
for item in function(self.params['certification'], page_no):
list_append((get_trakt_tvshow_id(item['show']['ids'])))
self.new_page = {
'new_page': string(page_no + 1),
'certification': self.params['certification']
}
elif self.action == 'trakt_recommendations':
for item in function('shows'):
list_append(get_trakt_tvshow_id(item['ids']))
elif self.action == 'tmdb_tv_search':
query = self.params['query']
data = function(query, page_no)
total_pages = data['total_pages']
if total_pages > page_no:
self.new_page = {
'new_page': string(page_no + 1),
'query': query
}
self.list = [i['id'] for i in data['results']]
elif self.action == 'trakt_tv_search':
query = self.params['query']
data, total_pages = function(query, page_no, letter)
for item in data:
list_append(get_trakt_tvshow_id(item['show']['ids']))
if total_pages > page_no:
self.new_page = {
'new_page': string(page_no + 1),
'new_letter': letter,
'query': query
}
if self.total_pages and not self.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,
'query': params_get('search_name', ''),
'actor_id': params_get('actor_id', '')
}
self.add_dir(url_params, jumpto_str, item_jump, False)
kodi_utils.add_items(self.handle, self.worker())
if self.new_page:
self.new_page.update({
'mode': mode,
'action': self.action,
'exit_list_params': self.exit_list_params
})
self.add_dir(self.new_page)
except:
pass
kodi_utils.set_content(self.handle, content_type)
kodi_utils.end_directory(self.handle)
kodi_utils.set_view_mode('view.tvshows', content_type)
def search_history(params):
def _builder():
for h in history:
try:
cm = []
query = unquote(h)
url_params = {'mode': 'get_search_term', 'db_type': 'movie', 'query': query} if action == 'movie' \
else {'mode': 'get_search_term', 'db_type': 'tv_show', 'query': query} if action == 'tvshow' \
else {'mode': 'people_search.search', 'actor_name': query} if action == 'people' \
else {'mode': 'furk.search_furk', 'db_type': 'video', 'query': query} if action == 'furk_video' \
else {'mode': 'furk.search_furk', 'db_type': 'audio', 'music': True, 'query': query} if action == 'furk_audio' \
else {'mode': 'easynews.search_easynews', 'query': query} if action == 'easynews_video' \
else {'mode': 'get_search_term', 'search_type': 'imdb_keyword', 'db_type': 'movie', 'query': query} if action == 'imdb_keyword_movie' \
else {'mode': 'get_search_term', 'search_type': 'imdb_keyword', 'db_type': 'tvshow', 'query': query} if action == 'imdb_keyword_tvshow' \
else ''
isFolder = False if action in folder_actions else True
display = '[B]%s %s : [/B]' % (display_title, sear_str) + query
url = build_url(url_params)
cm.append(
(remove_str, 'RunPlugin(%s)' % build_url({
'mode': 'remove_from_history',
'setting_id': search_setting,
'query': query
})))
listitem = make_listitem()
listitem.setLabel(display)
listitem.setArt({
'icon': icon,
'poster': icon,
'thumb': icon,
'fanart': fanart,
'banner': icon
})
listitem.addContextMenuItems(cm)
yield (url, listitem, isFolder)
except:
pass
try:
__handle__ = int(argv[1])
sear_str, mov_str, tv_str, peop_str = ls(32450).upper(), ls(
32028).upper(), ls(32029).upper(), ls(32507).upper()
furkvid_str = '%s %s' % (ls(32069).upper(), ls(32491).upper())
furkaud_str = '%s %s' % (ls(32069).upper(), ls(32492).upper())
imdb_key_mov_str, imdb_key_tv_str = '%s %s %s' % (
ls(32064).upper(), ls(32092).upper(), mov_str), '%s %s %s' % (
ls(32064).upper(), ls(32092).upper(), tv_str)
remove_str, easy_str = ls(32786), ls(32070).upper()
action = params['action']
search_setting, display_title = {
'movie': ('movie_queries', mov_str),
'tvshow': ('tvshow_queries', tv_str),
'people': ('people_queries', peop_str),
'furk_video': ('furk_video_queries', furkvid_str),
'furk_audio': ('furk_audio_queries', furkaud_str),
'easynews_video': ('easynews_video_queries', easy_str),
'imdb_keyword_movie':
('imdb_keyword_movie_queries', imdb_key_mov_str),
'imdb_keyword_tvshow':
('imdb_keyword_tvshow_queries', imdb_key_tv_str)
}[action]
history = main_cache.get(search_setting)
__handle__ = int(argv[1])
kodi_utils.add_items(__handle__, list(_builder()))
except:
pass
kodi_utils.set_content(__handle__, '')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.main', '')
def rd_downloads():
def _builder():
for count, item in enumerate(my_downloads, 1):
try:
cm = []
cm_append = cm.append
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,
'media_type': 'video'
}
down_file_params = {
'mode': 'downloader',
'name': name,
'url': url_link,
'action': 'cloud.realdebrid_direct',
'image': default_rd_icon
}
delete_params = {
'mode': 'real_debrid.delete',
'id': item['id'],
'cache_type': 'download'
}
cm_append(
(down_str, 'RunPlugin(%s)' % build_url(down_file_params)))
cm_append(
('[B]%s %s[/B]' % (delete_str, file_str.capitalize()),
'RunPlugin(%s)' % build_url(delete_params)))
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_rd_icon,
'poster': default_rd_icon,
'thumb': default_rd_icon,
'fanart': fanart,
'banner': default_rd_icon
})
yield (url, listitem, True)
except:
pass
__handle__ = int(argv[1])
try:
my_downloads = RealDebrid.downloads()
except:
return
extensions = supported_video_extensions()
my_downloads = [
i for i in my_downloads
if i['download'].lower().endswith(tuple(extensions))
]
file_str, down_str, delete_str = ls(32743), ls(32747), ls(32785)
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def pm_torrent_cloud(folder_id=None, folder_name=None):
def _builder():
for count, item in enumerate(cloud_files, 1):
try:
cm = []
cm_append = cm.append
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']
}
delete_params = {'mode': 'premiumize.delete', 'id': item['id']}
if file_type == 'folder':
is_folder = True
download_string = archive_str
delete_params['file_type'] = 'folder'
string = folder_str
display = '%02d | [B]%s[/B] | [I]%s [/I]' % (
count, folder_str, name)
url_params = {
'mode': 'premiumize.pm_torrent_cloud',
'id': item['id'],
'folder_name': normalize(item['name'])
}
else:
is_folder = False
download_string = down_str
delete_params['file_type'] = 'item'
string = file_str
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_str, display_size, name)
url_params = {
'mode': 'media_play',
'url': url_link,
'media_type': 'video'
}
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': url_link,
'action': 'cloud.premiumize',
'image': default_pm_icon
}
cm_append((download_string,
'RunPlugin(%s)' % build_url(down_file_params)))
cm_append((rename_str % file_type.capitalize(),
'RunPlugin(%s)' % build_url(rename_params)))
cm_append(('[B]%s %s[/B]' % (delete_str, string.capitalize()),
'RunPlugin(%s)' % build_url(delete_params)))
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_pm_icon,
'poster': default_pm_icon,
'thumb': default_pm_icon,
'fanart': fanart,
'banner': default_pm_icon
})
yield (url, listitem, is_folder)
except:
pass
__handle__ = int(argv[1])
folder_str, file_str, down_str, archive_str, rename_str, delete_str = ls(
32742).upper(), ls(32743).upper(), ls(32747), ls(32982), ls(32748), ls(
32785)
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.sort(key=lambda k: k['name'])
cloud_files.sort(key=lambda k: k['type'], reverse=True)
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def build_season_list(params):
def _process():
running_ep_count = total_aired_eps
def _unaired_status():
if episode_count == 0: return True
season_date_start = adjust_premiered_date(air_date, 0)[0]
if not season_date_start or current_date < season_date_start:
return True
return False
for item in season_data:
try:
listitem = make_listitem()
set_property = listitem.setProperty
cm = []
cm_append = cm.append
item_get = item.get
overview = item_get('overview')
name = item_get('name')
poster_path = item_get('poster_path')
air_date = item_get('air_date')
season_number = item_get('season_number')
episode_count = item_get('episode_count')
season_poster = 'https://image.tmdb.org/t/p/%s%s' % (
image_resolution,
poster_path) if poster_path is not None else show_poster
if season_number == 0: unaired = False
else:
unaired = _unaired_status()
if unaired:
if not show_unaired: return
episode_count = 0
else:
running_ep_count -= episode_count
if running_ep_count < 0:
episode_count = running_ep_count + episode_count
try:
year = air_date.split('-')[0]
except:
year = show_year
plot = overview if overview != '' else show_plot
title = name if use_season_title and name != '' else '%s %s' % (
season_str, string(season_number))
if unaired: title = unaired_label % title
playcount, overlay, watched, unwatched = get_watched_status_season(
watched_info, string(tmdb_id), season_number,
episode_count)
url_params = build_url({
'mode': 'build_episode_list',
'tmdb_id': tmdb_id,
'season': season_number
})
extras_params = build_url({
'mode': 'extras_menu_choice',
'tmdb_id': tmdb_id,
'db_type': 'tvshow',
'is_widget': is_widget
})
options_params = build_url({
'mode': 'options_menu_choice',
'content': 'season',
'tmdb_id': tmdb_id
})
cm_append((extras_str, run_plugin % extras_params))
cm_append((options_str, run_plugin % options_params))
if not playcount:
watched_params = build_url({
'mode': 'mark_as_watched_unwatched_season',
'action': 'mark_as_watched',
'title': show_title,
'year': show_year,
'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id,
'season': season_number
})
cm_append((watched_str % watched_title,
run_plugin % watched_params))
if watched:
unwatched_params = build_url({
'mode': 'mark_as_watched_unwatched_season',
'action': 'mark_as_unwatched',
'title': show_title,
'year': show_year,
'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id,
'season': season_number
})
cm_append((unwatched_str % watched_title,
run_plugin % unwatched_params))
listitem.setLabel(title)
listitem.setContentLookup(False)
listitem.addContextMenuItems(cm)
listitem.setArt({
'poster': season_poster,
'icon': season_poster,
'thumb': season_poster,
'fanart': fanart,
'banner': banner,
'clearart': clearart,
'clearlogo': clearlogo,
'landscape': landscape,
'tvshow.clearart': clearart,
'tvshow.clearlogo': clearlogo,
'tvshow.landscape': landscape,
'tvshow.banner': banner
})
listitem.setCast(cast)
listitem.setUniqueIDs({
'imdb': imdb_id,
'tmdb': string(tmdb_id),
'tvdb': string(tvdb_id)
})
listitem.setInfo(
'video', {
'mediatype': 'season',
'trailer': trailer,
'title': title,
'size': '0',
'duration': episode_run_time,
'plot': plot,
'rating': rating,
'premiered': premiered,
'studio': studio,
'year': year,
'genre': genre,
'mpaa': mpaa,
'tvshowtitle': show_title,
'imdbnumber': imdb_id,
'votes': votes,
'season': season_number,
'playcount': playcount,
'overlay': overlay
})
set_property('watchedepisodes', string(watched))
set_property('unwatchedepisodes', string(unwatched))
set_property('totalepisodes', string(episode_count))
if is_widget:
set_property('fen_widget', 'true')
set_property('fen_playcount', string(playcount))
set_property('fen_extras_menu_params', extras_params)
set_property('fen_options_menu_params', options_params)
else:
set_property('fen_widget', 'false')
yield (url_params, listitem, True)
except:
pass
__handle__ = int(argv[1])
meta_user_info = metadata.retrieve_user_info()
watched_indicators = settings.watched_indicators()
watched_info = get_watched_info_tv(watched_indicators)
show_unaired = settings.show_unaired()
is_widget = kodi_utils.external_browse()
current_date = get_datetime()
image_resolution = meta_user_info['image_resolution']['poster']
poster_main, poster_backup, fanart_main, fanart_backup = settings.get_art_provider(
)
meta = metadata.tvshow_meta('tmdb_id', params['tmdb_id'], meta_user_info)
meta_get = meta.get
season_data = meta_get('season_data')
if not season_data: return
tmdb_id, tvdb_id, imdb_id = meta_get('tmdb_id'), meta_get(
'tvdb_id'), meta_get('imdb_id')
show_title, show_year, show_plot, banner = meta_get('title'), meta_get(
'year'), meta_get('plot'), meta_get('banner')
show_poster = meta_get(poster_main) or meta_get(
poster_backup) or poster_empty
fanart = meta_get(fanart_main) or meta_get(fanart_backup) or fanart_empty
clearlogo, clearart, landscape = meta_get('clearlogo'), meta_get(
'clearart'), meta_get('landscape')
cast, mpaa, votes = meta_get('cast'), meta_get('mpaa'), meta_get('votes')
trailer, genre, studio = string(
meta_get('trailer')), meta_get('genre'), meta_get('studio')
episode_run_time, rating, premiered = meta_get(
'episode_run_time'), meta_get('rating'), meta_get('premiered')
total_seasons = meta_get('total_seasons')
total_aired_eps = meta_get('total_aired_eps')
if not settings.show_specials():
season_data = [i for i in season_data if not i['season_number'] == 0]
season_data.sort(key=lambda k: k['season_number'])
use_season_title = settings.use_season_title()
watched_title = 'Trakt' if watched_indicators == 1 else 'Fen'
kodi_utils.add_items(__handle__, list(_process()))
kodi_utils.set_content(__handle__, 'seasons')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.seasons', 'seasons')
def ad_torrent_cloud(folder_id=None):
def _builder():
for count, item in enumerate(cloud_dict, 1):
try:
cm = []
cm_append = cm.append
folder_name = item['filename']
normalized_folder_name = normalize(folder_name)
string = 'FEN_AD_%s' % normalized_folder_name
link_folders_add = {
'mode': 'link_folders',
'service': 'AD',
'folder_name': normalized_folder_name,
'action': 'add'
}
link_folders_remove = {
'mode': 'link_folders',
'service': 'AD',
'folder_name': normalized_folder_name,
'action': 'remove'
}
current_link = main_cache.get(string)
if current_link:
ending = '[COLOR=limegreen][B][I]\n %s[/I][/B][/COLOR]' % (
linkedto_str % current_link)
else:
ending = ''
display = '%02d | [B]%s[/B] | [I]%s [/I]%s' % (
count, folder_str,
clean_file_name(normalized_folder_name).upper(), ending)
url_params = {
'mode': 'alldebrid.browse_ad_cloud',
'folder': json.dumps(item['links'])
}
url = build_url(url_params)
cm_append((addlink_str,
'RunPlugin(%s)' % build_url(link_folders_add)))
cm_append((clearlink_str,
'RunPlugin(%s)' % build_url(link_folders_remove)))
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_ad_icon,
'poster': default_ad_icon,
'thumb': default_ad_icon,
'fanart': fanart,
'banner': default_ad_icon
})
yield (url, listitem, True)
except:
pass
__handle__ = int(argv[1])
folder_str, archive_str, linkedto_str, addlink_str, clearlink_str = ls(
32742).upper(), ls(32982), ls(32744), ls(32745), ls(32746)
cloud_dict = AllDebrid.user_cloud()['magnets']
cloud_dict = [i for i in cloud_dict if i['statusCode'] == 4]
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def browse_audio_album(t_files, item_path=None):
def build_list_object():
try:
cm = []
url_params = {
'mode': 'media_play',
'url': item['url_dl'],
'media_type': 'music'
}
url = build_url(url_params)
track_name = clean_file_name(
batch_replace(to_utf8(item['name']), formats)).upper()
listitem = make_listitem()
listitem.setLabel(track_name)
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': item['url_dl'],
'action': 'audio',
'image': default_furk_icon
}
cm.append(
(ls(32747), '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
})
kodi_utils.add_item(__handle__, url, listitem, True)
except:
pass
from modules.utils import batch_replace
__handle__ = int(argv[1])
seperate = False
if not t_files:
seperate = True
t_fs = kodi_utils.get_property('furk_t_files_json')
t_files = json.loads(t_fs)
t_files = [i for i in t_files if 'audio' in i['ct']]
line = '%s[CR]%s[CR]%s'
if seperate:
if kodi_utils.confirm_dialog(text=32763,
ok_label=32838,
cancel_label=32764,
top_space=True):
for item in t_files:
t_path = clean_file_name(item['path'])
if t_path == item_path:
build_list_object()
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
else:
from modules.player import FenPlayer
FenPlayer().playAudioAlbum(t_files, from_seperate=True)
else:
for item in t_files:
build_list_object()
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def build_next_episode_manager(params):
def build_content(tmdb_id):
try:
cm = []
listitem = make_listitem()
set_property = listitem.setProperty
cm_append = cm.append
meta = tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
meta_get = meta.get
total_aired_eps = meta_get('total_aired_eps')
total_seasons = meta_get('total_seasons')
title = meta_get('title')
playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow(
watched_info, tmdb_id, total_aired_eps)
meta.update({'playcount': playcount, 'overlay': overlay})
if tmdb_id in exclude_list:
color, action, status, sort_value = 'red', 'unhide', excluded_str, 1
else:
color, action, status, sort_value = 'green', 'hide', included_str, 0
display = '[COLOR=%s][%s][/COLOR] %s' % (color, status, title)
extras_params = {
'mode': 'extras_menu_choice',
'tmdb_id': tmdb_id,
'db_type': 'tvshow',
'is_widget': 'False'
}
url_params = {
'mode': 'hide_unhide_trakt_items',
'action': action,
'media_type': 'shows',
'media_id': meta_get('imdb_id'),
'section': 'progress_watched'
}
url = build_url(url_params)
if show_all_episodes:
if all_episodes == 1 and total_seasons > 1:
browse_params = {
'mode': 'build_season_list',
'tmdb_id': tmdb_id
}
else:
browse_params = {
'mode': 'build_episode_list',
'tmdb_id': tmdb_id,
'season': 'all'
}
else:
browse_params = {
'mode': 'build_season_list',
'tmdb_id': tmdb_id
}
cm_append((extras_str, 'RunPlugin(%s)' % build_url(extras_params)))
cm_append((browse_str,
'Container.Update(%s)' % build_url(browse_params)))
listitem.setLabel(display)
set_property('watchedepisodes', str(total_watched))
set_property('unwatchedepisodes', str(total_unwatched))
set_property('totalepisodes', str(total_aired_eps))
set_property('totalseasons', str(total_seasons))
listitem.addContextMenuItems(cm)
listitem.setArt({
'poster': meta_get('poster'),
'fanart': meta_get('fanart'),
'banner': meta_get('banner'),
'clearart': meta_get('clearart'),
'clearlogo': meta_get('clearlogo'),
'landscape': meta_get('landscape')
})
listitem.setCast(meta['cast'])
listitem.setInfo('video', remove_meta_keys(meta, dict_removals))
append({
'listitem': (url, listitem, False),
'sort_value': sort_value,
'sort_title': title
})
except:
pass
__handle__ = int(argv[1])
list_items = []
append = list_items.append
meta_user_info, watched_indicators, watched_info, all_episodes, include_year_in_title, open_extras = get_tvshow_info(
)
ep_list = get_next_episodes(watched_info)
tmdb_list = [i['tmdb_id'] for i in ep_list]
try:
exclude_list = trakt_get_hidden_items('progress_watched')
except:
exclude_list = []
show_all_episodes = True if all_episodes in (1, 2) else False
threads = list(make_thread_list(build_content, tmdb_list, Thread))
[i.join() for i in threads]
item_list = sorted(
list_items,
key=lambda k:
(k['sort_value'], title_key(k['sort_title'], ignore_articles())),
reverse=False)
item_list = [i['listitem'] for i in item_list]
kodi_utils.add_dir({'mode': 'nill'},
'[I][COLOR=grey2]%s[/COLOR][/I]' % heading.upper(),
__handle__,
iconImage='settings.png',
isFolder=False)
kodi_utils.add_items(__handle__, item_list)
kodi_utils.set_content(__handle__, 'tvshows')
kodi_utils.end_directory(__handle__, cacheToDisc=False)
kodi_utils.set_view_mode('view.main', 'tvshows')
kodi_utils.focus_index(1)
def browse_rd_cloud(folder_id):
def _builder():
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]%s[/B] | %.2f GB | [I]%s [/I]' % (
count, file_str, size, name)
url_params = {
'mode': 'real_debrid.resolve_rd',
'url': url_link,
'play': 'true'
}
url = build_url(url_params)
down_file_params = {
'mode': 'downloader',
'name': name,
'url': url_link,
'action': 'cloud.realdebrid',
'image': default_rd_icon
}
cm.append(
(down_str, 'RunPlugin(%s)' % build_url(down_file_params)))
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_rd_icon,
'poster': default_rd_icon,
'thumb': default_rd_icon,
'fanart': fanart,
'banner': default_rd_icon
})
listitem.setInfo('video', {})
yield (url, listitem, False)
except:
pass
__handle__ = int(argv[1])
torrent_files = RealDebrid.user_cloud_info(folder_id)
extensions = supported_video_extensions()
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'])
file_str, down_str = ls(32743).upper(), ls(32747)
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def _end_directory(self):
__handle__ = int(argv[1])
kodi_utils.set_content(__handle__, '')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode(self.view, '')
def rd_torrent_cloud():
def _builder():
for count, item in enumerate(my_cloud_files, 1):
try:
cm = []
cm_append = cm.append
folder_name = item['filename']
normalized_folder_name = normalize(folder_name)
string = 'FEN_RD_%s' % normalized_folder_name
link_folders_add = {
'mode': 'link_folders',
'service': 'RD',
'folder_name': normalized_folder_name,
'action': 'add'
}
link_folders_remove = {
'mode': 'link_folders',
'service': 'RD',
'folder_name': normalized_folder_name,
'action': 'remove'
}
current_link = main_cache.get(string)
if current_link:
ending = '[COLOR=limegreen][B][I]\n %s[/I][/B][/COLOR]' % (
linkedto_str % current_link)
else:
ending = ''
display = '%02d | [B]%s[/B] | [I]%s [/I]%s' % (
count, folder_str,
clean_file_name(normalized_folder_name).upper(), ending)
url_params = {
'mode': 'real_debrid.browse_rd_cloud',
'id': item['id']
}
delete_params = {
'mode': 'real_debrid.delete',
'id': item['id'],
'cache_type': 'torrent'
}
url = build_url(url_params)
cm_append(
('[B]%s %s[/B]' % (delete_str, folder_str.capitalize()),
'RunPlugin(%s)' % build_url(delete_params)))
cm_append((addlink_str,
'RunPlugin(%s)' % build_url(link_folders_add)))
cm_append((clearlink_str,
'RunPlugin(%s)' % build_url(link_folders_remove)))
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_rd_icon,
'poster': default_rd_icon,
'thumb': default_rd_icon,
'fanart': fanart,
'banner': default_rd_icon
})
yield (url, listitem, True)
except:
pass
__handle__ = int(argv[1])
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']
folder_str, linkedto_str, addlink_str, clearlink_str, delete_str = ls(
32742).upper(), ls(32744), ls(32745), ls(32746), ls(32785)
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
