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)
