def torrent_status_browser(files):
from datetime import timedelta
from resources.lib.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)
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.furk_files')
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 resources.lib.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.setThumbnailImage(default_furk_icon)
listitem.setArt({'fanart': fanart})
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.furk_files')
def build_in_progress_episode():
from resources.lib.indexers.tvshows import make_fresh_tvshow_meta
from resources.lib.modules.workers import Thread
def process_eps(item):
listitem = build_episode({
"season":
int(item[1]),
"episode":
int(item[2]),
"meta":
make_fresh_tvshow_meta('tmdb_id', item[0])
})['listitem']
xbmcplugin.addDirectoryItem(__handle__,
listitem[0],
listitem[1],
isFolder=listitem[2])
settings.check_database(WATCHED_DB)
threads = []
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, season, episode FROM progress WHERE db_type=?''',
('episode', ))
rows = dbcur.fetchall()
for item in rows:
threads.append(Thread(process_eps, item))
[i.start() for i in threads]
[i.join() for i in threads]
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__)
setView('view.progress_next_episode')
def playAudioAlbum(self, t_files=None, name=None, from_seperate=False):
import os
import xbmcaddon
from resources.lib.modules.utils import clean_file_name, batch_replace, to_utf8
from resources.lib.modules.nav_utils import setView
__addon_id__ = 'plugin.video.fen'
__addon__ = xbmcaddon.Addon(id=__addon_id__)
__handle__ = int(sys.argv[1])
addon_dir = xbmc.translatePath(__addon__.getAddonInfo('path'))
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 my_furk_audio_favourites():
from resources.lib.modules.favourites import retrieve_favourites
results = retrieve_favourites('audio', '', '')
for item in results:
try:
cm = []
name = item.split('<>')[0]
item_id = item.split('<>')[1]
url_dl = item.split('<>')[2]
size = item.split('<>')[3]
display_size = str(round(float(size) / 1048576000, 1))
display = '[B]%sGB[/B] | [I]%s[/I]' % (display_size, name)
url_params = {
'mode': 'furk.furk_tfile_audio',
'name': name,
'id': item_id
}
url = build_url(url_params)
con_remove_favs = {
'mode': 'remove_from_favourites',
'db_type': 'audio',
'tmdb_id': item
}
con_download_archive = {
'mode': 'download_file',
'name': name,
'url': url_dl,
'image': default_furk_icon,
'db_type': 'archive'
}
cm.append(("[B]Remove from Fen Favourites[/B]",
'XBMC.RunPlugin(%s)' % build_url(con_remove_favs)))
cm.append(("[B]Download Archive[/B]",
'XBMC.RunPlugin(%s)' % build_url(con_download_archive)))
listitem = xbmcgui.ListItem(display)
listitem.addContextMenuItems(cm)
listitem.setThumbnailImage(default_furk_icon)
listitem.setArt({'fanart': fanart})
listitem.setInfo(type='video',
infoLabels={
'title': display,
'size': int(size)
})
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(__handle__, 'files')
xbmcplugin.endOfDirectory(__handle__)
setView('view.furk_files')
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.furk_files')
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': 'nill'
}
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.setThumbnailImage(default_furk_icon)
listitem.setArt({'fanart': fanart})
listitem.setInfo(
'video', {
'title': display_name,
'size': int(item['size']),
'duration': item['length']
})
listitem.setProperty("IsPlayable", "true")
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(__handle__, 'files')
xbmcplugin.endOfDirectory(__handle__)
setView('view.furk_files')
def search_history():
import xbmc, xbmcgui, xbmcplugin
import sys, os
from urlparse import parse_qsl
import urllib
from resources.lib.modules.nav_utils import build_url, setView
from resources.lib.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 ('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
for h in history:
try:
cm = []
name = urllib.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': '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,
iconImage=os.path.join(
get_theme(), 'search.png'))
listitem.setArt({
'fanart':
os.path.join(
xbmc.translatePath(__addon__.getAddonInfo('path')),
'fanart.png')
})
listitem.setInfo(type='video', infoLabels={'Title': name})
listitem.addContextMenuItems(cm)
xbmcplugin.addDirectoryItem(int(sys.argv[1]),
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(int(sys.argv[1]), 'files')
xbmcplugin.endOfDirectory(int(sys.argv[1]))
setView('view.main')
def display_results(self):
def _build_directory(item, item_no):
try:
uncached = item.get('uncached', False)
external = item.get('external', False)
mode = 'furk.add_uncached_file' if uncached else 'play_file'
url = build_url({'mode': mode, 'title': item.get('title'), 'source': json.dumps([item])})
cm = []
if external: display_name = item.get("label")
else: display_name = item.get("display_name")
display = '%02d | %s' % (item_no+1, display_name)
listitem = xbmcgui.ListItem(display)
listitem.setArt({'poster': meta['poster'], 'fanart': meta['fanart'], 'thumb': meta['poster']})
playback_params = {'mode': 'playback_menu', 'from_results': True}
cm.append(("[B]Options[/B]",'XBMC.RunPlugin(%s)' % build_url(playback_params)))
if not uncached:
if item['scrape_provider'] == 'furk':
add_files_params = {'mode': 'furk.add_to_files', 'name': item.get("name"), 'item_id': item.get("id")}
cm.append(("[B]Add to My Files[/B]",'XBMC.RunPlugin(%s)' % build_url(add_files_params)))
if 'PACK' in display:
down_archive_params = {'mode': 'download_file', 'name': item.get("name"), 'url': item.get("url_dl"), 'db_type': 'archive', 'image': default_furk_icon}
cm.append(("[B]Download Archive[/B]",'XBMC.RunPlugin(%s)' % build_url(down_archive_params)))
if item['scrape_provider'] not in ('local', 'downloads'):
down_file_params = {'mode': 'download_file', 'name': meta.get('rootname'), 'url': item.get("url_dl"), 'image': meta.get('poster', ''), 'source': json.dumps([item]), 'meta': meta_json}
if item['scrape_provider'] == 'furk': down_file_params['archive'] = True
cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params)))
listitem.addContextMenuItems(cm)
if meta['vid_type'] == 'movie': listitem.setInfo('video', {'title': meta.get('title', ''), 'year': meta.get('year', ''), 'plot': meta.get('plot', '')})
elif meta['vid_type'] == 'episode': listitem.setInfo('video', {'title': meta.get('rootname', ''), 'plot': meta.get('plot', '')})
item_list.append({'url': url, 'list_item': listitem, 'item_no': item_no})
except: pass
xbmc.PlayList(xbmc.PLAYLIST_VIDEO).clear()
xbmc.PlayList(xbmc.PLAYLIST_MUSIC).clear()
item_list = []
threads = []
try: results = json.loads(window.getProperty('fen_search_results'))
except: return
meta = json.loads(window.getProperty('fen_media_meta'))
meta_json = window.getProperty('fen_media_meta')
if results[0].get('play_local', False) or results[0].get('play_downloads', False) or results[0].get('autoplay', False): return self.play_auto()
total = len(results)
[threads.append(Thread(_build_directory, results[i], i)) for i in range(total) if i <= total]
[i.start() for i in threads]
[i.join() for i in threads]
item_list = sorted(item_list, key=lambda k: k['item_no'])
for i in item_list: xbmcplugin.addDirectoryItem(__handle__, i['url'], i['list_item'], isFolder=True)
xbmcplugin.setContent(__handle__, 'files')
xbmcplugin.endOfDirectory(__handle__)
setView('view.media_results')
def furkTFile(self, file_id):
from resources.lib.modules.furk_api import FurkAPI
from resources.lib.indexers.furk import get_release_quality
hide_busy_dialog()
close_all_dialog()
t_files = FurkAPI().t_files(file_id)
t_files = [i for i in t_files if 'video' in i['ct'] and 'bitrate' in i]
meta = json.loads(window.getProperty('fen_media_meta'))
from_library = meta.get('from_library', False)
not_widget = xbmc.getInfoLabel('Container.PluginName')
use_dialog = True if from_library or not not_widget else settings.use_dialog()
display_list = []
if use_dialog:
display_list = ['%02d | [B]%s[/B] | [B]%.2f GB[/B] | [I]%s[/I]' % \
(count, get_release_quality(i['name'], i['url_dl'], t_file='yep')[0],
float(i['size'])/1073741824,
clean_file_name(i['name']).upper()) for count, i in enumerate(t_files, 1)]
chosen = dialog.select("Fen Results", display_list)
if chosen < 0: return None
chosen_result = t_files[chosen]
url_dl = chosen_result['url_dl']
from resources.lib.modules.player import FenPlayer
return FenPlayer().run(url_dl)
for count, item in enumerate(t_files, 1):
try:
cm = []
url_params = {'mode': 'media_play', 'url': item['url_dl']}
url = build_url(url_params)
name = clean_file_name(item['name'])
video_quality, video_type = get_release_quality(item['name'], item['url_dl'], t_file='yep')
json_meta = json.dumps(meta)
display_name = '%02d | [B]%s[/B] | [B]%s[/B] | [B]%.2f GB[/B] | [I]%s[/I]' % (count, video_quality, video_type, float(item['size'])/1073741824, name.upper())
listitem = xbmcgui.ListItem(display_name)
listitem.setArt({'poster': meta.get('poster', ''), 'thumb': meta.get('poster', ''), 'fanart': meta.get('fanart')})
playback_params = {'mode': 'playback_menu', 'from_results': True}
down_file_params = {'mode': 'download_file', 'name': item['name'], 'url': item['url_dl'], 'meta': json_meta}
cm.append(("[B]Options[/B]",'XBMC.RunPlugin(%s)' % build_url(playback_params)))
cm.append(("[B]Download File[/B]",'XBMC.RunPlugin(%s)' % build_url(down_file_params)))
listitem.addContextMenuItems(cm)
if meta.get('vid_type') == 'movie': listitem.setInfo('video', {'title': meta.get('title', ''), 'year': meta.get('year', ''), 'plot': meta.get('plot', '')})
else: listitem.setInfo('video', {'title': meta['rootname'], 'plot': meta.get('plot', '')})
xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True)
except: pass
xbmcplugin.setContent(__handle__, 'files')
xbmcplugin.endOfDirectory(__handle__)
setView('view.pack_results')
def search_easynews():
from resources.lib.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))
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.easynews_files')
def build_next_episode():
sync_watched_trakt_to_fen()
try:
threads = []
seen = set()
ep_list = []
ne_settings = settings.nextep_content_settings()
ne_display = settings.nextep_display_settings()
if ne_settings['include_unwatched']:
for i in get_unwatched_next_episodes(): ep_list.append(i)
if settings.watched_indicators() in (1, 2):
from resources.lib.modules.trakt import trakt_get_next_episodes
info = trakt_get_next_episodes()
for item in info:
try:
ep_list.append({"tmdb_id": get_trakt_tvshow_id(item), "season": item['season'], "episode": item['number'], "last_played": item['show']['last_watched_at']})
except: pass
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(process_eps, item, ne_settings, ne_display))
[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, ne_settings)
listitems = [i['listitem'] for i in r]
xbmcplugin.addDirectoryItems(__handle__, listitems, len(listitems))
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__)
setView('view.progress_next_episode')
except:
from resources.lib.modules.nav_utils import notification
notification('Error getting Next Episode Info', time=3500)
pass
def search_furk():
from resources.lib.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.furk_files')
def build_next_episode_manager():
from urlparse import parse_qsl
from resources.lib.indexers.tvshows import aired_episode_number_tvshow
from resources.lib.modules.nav_utils import add_dir
from resources.lib.modules.indicators_bookmarks import get_watched_status_tvshow
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'
VIEW_NEM = __addon__.getSetting('view.main')
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 resources.lib.modules.trakt 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:'
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 resources.lib.modules.nav_utils import notification
notification('No Shows Present', time=5000)
else:
for tmdb_id in tmdb_list:
try:
meta = make_fresh_tvshow_meta('tmdb_id', tmdb_id)
if action == 'manage_unwatched':
action, display = 'remove', '[COLOR=%s][UNWATCHED][/COLOR] %s' % (NEXT_EP_UNWATCHED, meta['title'])
url_params = {'mode': 'add_next_episode_unwatched', 'action': 'remove', 'tmdb_id': meta['tmdb_id'], 'title': meta['title']}
elif settings.watched_indicators() in (1, 2):
action, display = 'unhide' if str(meta['tmdb_id']) in exclude_list else 'hide', '[COLOR=red][EXCLUDED][/COLOR] %s' % meta['title'] if str(meta['tmdb_id']) in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % meta['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 str(meta['tmdb_id']) in exclude_list else 'add', '[COLOR=red][EXCLUDED][/COLOR] %s' % meta['title'] if str(meta['tmdb_id']) in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % meta['title']
url_params = {'mode': 'add_to_remove_from_next_episode_excludes', 'action': action, 'title': meta['title'], 'media_id': meta['tmdb_id']}
sorted_list.append({'tmdb_id': tmdb_id, 'display': display, 'url_params': url_params, 'meta': json.dumps(meta)})
except: pass
sorted_items = sorted(sorted_list, key=lambda k: k['display'])
for i in sorted_items:
try:
cm = []
meta = json.loads(i['meta'])
rootname = meta['title'] + " (" + str(meta['year']) + ")"
meta['rootname'] = rootname
aired_episodes = aired_episode_number_tvshow(meta)
playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow(meta['tmdb_id'], aired_episodes)
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(aired_episodes))
listitem.setProperty('totalseasons', str(meta['number_of_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', {
'title': meta['title'], 'size': '0', 'duration': meta['duration'],
'plot': meta['plot'], 'rating': meta['rating'], 'premiered': meta['premiered'],
'studio': meta['studio'],'year': meta['year'],
'genre': meta['genre'],'imdbnumber': meta['imdb_id'], 'votes': meta['votes'],
'playcount': playcount, 'overlay': overlay})
xbmcplugin.addDirectoryItem(__handle__, url, listitem, isFolder=True)
except: pass
xbmcplugin.setContent(__handle__, 'tvshows')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=False)
setView(VIEW_NEM)
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': 'nill'
}
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': 'furk_file'
}
cm.append(("[B]Download File[/B]",
'XBMC.RunPlugin(%s)' % build_url(down_file_params)))
listitem.addContextMenuItems(cm)
listitem.setThumbnailImage(default_furk_icon)
listitem.setArt({'fanart': fanart})
listitem.setInfo(type='music',
infoLabels={
'title': track_name,
'size': int(item['size']),
'album': item['path'],
'duration': item['length']
})
listitem.setProperty("IsPlayable", "true")
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=False)
except:
pass
from resources.lib.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.endOfDirectory(__handle__)
setView('view.furk_files')
else:
from resources.lib.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.furk_files')
def fetch_list(self):
try:
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
worker = True
mode = params.get('mode')
page_no = int(params.get('new_page', 1))
letter = params.get('new_letter', 'None')
search_name = ''
content_type = 'movies'
var_module = 'tmdb' if 'tmdb' in self.action else 'trakt' if 'trakt' in self.action else 'imdb' if 'imdb' in self.action else ''
try:
exec('from resources.lib.modules.%s import %s as function' %
(var_module, self.action))
except:
pass
if self.action in ('tmdb_movies_popular',
'tmdb_movies_blockbusters',
'tmdb_movies_in_theaters',
'tmdb_movies_top_rated', 'tmdb_movies_upcoming',
'tmdb_movies_latest_releases',
'tmdb_movies_premieres',
'trakt_movies_trending',
'trakt_movies_anticipated',
'trakt_movies_top10_boxoffice'):
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_movie_id(item))
if self.action not in ('trakt_movies_top10_boxoffice'):
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 in ('trakt_collection', 'trakt_watchlist'):
data, passed_list, total_pages, limit = function(
'movies', page_no, letter, params.get('passed_list', ''))
self.list = [i['media_id'] for i in data]
if total_pages > 1: self.total_pages = total_pages
if len(data) == limit:
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(page_no + 1),
'new_letter': letter,
'passed_list': passed_list,
'foldername': self.action
}
elif self.action == 'imdb_movies_oscar_winners':
self.id_type = 'imdb_id'
self.list = function(page_no)
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(page_no + 1),
'foldername': self.action
}
elif self.action == ('trakt_movies_mosts'):
for item in (function(params['period'], params['duration'],
page_no)):
self.list.append(get_trakt_movie_id(item))
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_movies_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_movies_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_movies_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(data['page'] + 1),
'year': params.get('year'),
'foldername': params.get('year')
}
elif self.action == 'tmdb_movies_certifications':
data = function(params['certification'], 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),
'certification': params.get('certification'),
'foldername': params.get('certification')
}
elif self.action in ('favourites_movies', 'subscriptions_movies',
'kodi_library_movies', 'watched_movies'):
(var_module, import_function) = (
'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:
exec(
'from resources.lib.modules.%s import %s as function' %
(var_module, import_function))
except:
return
if self.action == 'kodi_library_movies':
self.id_type = 'imdb_id'
data, passed_list, total_pages, limit = function(
'movie', page_no, letter, params.get('passed_list', ''))
self.list = [i['media_id'] for i in data]
if total_pages > 1: self.total_pages = total_pages
if len(data) == limit:
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(page_no + 1),
'new_letter': letter,
'passed_list': passed_list,
'foldername': self.action
}
elif self.action == 'in_progress_movies':
from resources.lib.modules.in_progress import in_progress_movie as function
self.list = function('movie')
xbmcplugin.addSortMethod(
__handle__, xbmcplugin.SORT_METHOD_LABEL_IGNORE_THE)
elif self.action == 'tmdb_movies_similar':
data = function(params['tmdb_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),
'foldername': self.action,
'tmdb_id': params.get('tmdb_id')
}
elif self.action == 'trakt_movies_related':
for item in function(params['imdb_id'], page_no):
self.list.append(get_trakt_movie_id(item))
self.new_page = {
'mode':
mode,
'action':
self.action,
'new_page':
str(
int((params.get('new_page') if 'new_page' in
params else 1)) + 1),
'foldername':
self.action,
'imdb_id':
params.get('imdb_id')
}
elif self.action == 'trakt_recommendations':
for item in function('movies'):
self.list.append(item['ids']['tmdb'])
elif self.action == 'tmdb_popular_people':
import os
worker = False
icon_directory = settings.get_theme()
data = function(page_no)
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, 'app_logo.png')
url_params = {
'mode': 'build_movie_list',
'action': 'tmdb_movies_actor_roles',
'actor_id': item['id']
}
url = build_url(url_params)
cm.append((
"[B]Extended Info[/B]",
'RunScript(script.extendedinfo,info=extendedactorinfo,id=%s)'
% item['id']))
listitem = xbmcgui.ListItem(item['name'])
listitem.setArt({
'poster': actor_poster,
'fanart': __addon__.getAddonInfo('fanart')
})
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_movies_actor_roles':
data, passed_list, total_pages, limit = function(
params['actor_id'], page_no, letter,
params.get('passed_list', ''))
self.list = [i['media_id'] for i in data]
if total_pages > 1: self.total_pages = total_pages
if len(data) == limit:
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(page_no + 1),
'new_letter': letter,
'passed_list': passed_list,
'actor_id': params['actor_id'],
'foldername': self.action
}
elif self.action in ('tmdb_movies_search',
'tmdb_movies_people_search'):
import urllib
if params.get('query') == 'NA':
search_title = dialog.input("Search Fen",
type=xbmcgui.INPUT_ALPHANUM)
search_name = urllib.unquote(search_title)
else:
search_name = urllib.unquote(params.get('query'))
if not search_name: return
if self.action == 'tmdb_movies_people_search':
data, passed_list, total_pages, limit = function(
search_name, page_no, letter,
params.get('passed_list', ''))
if total_pages > 1: self.total_pages = total_pages
if len(data) == limit:
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(page_no + 1),
'new_letter': letter,
'passed_list': passed_list,
'query': search_name,
'foldername': search_name
}
else:
data = function(search_name, page_no)
if self.action == 'tmdb_movies_search':
if data['page'] < data['total_pages']:
self.new_page = {
'mode': mode,
'action': self.action,
'new_page': str(int(data['page']) + 1),
'query': search_name,
'foldername': search_name
}
self.list = [i['id'] for i in data['results']
] if self.action == 'tmdb_movies_search' else [
i['media_id'] for i in data
]
if self.total_pages:
url_params = {
'mode': 'build_navigate_to_page',
'db_type': 'Movies',
'current_page': page_no,
'total_pages': self.total_pages,
'transfer_mode': mode,
'transfer_action': self.action,
'passed_list': passed_list,
'foldername': self.action,
'query': 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 worker: self.worker()
if self.new_page: self.add_dir(self.new_page)
except:
pass
xbmcplugin.setContent(__handle__, content_type)
xbmcplugin.endOfDirectory(__handle__)
setView('view.movies')
def build_season_list():
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
meta = json.loads(
params.get('meta')) if 'meta' in params else tikimeta.tvshow_meta(
'tmdb_id', params.get('tmdb_id'))
show_specials = settings.show_specials()
use_season_title = settings.use_season_title()
season_data = [i for i in meta['season_data'] if i['season_number'] > 0
] if not show_specials else meta['season_data']
watched_indicators = settings.watched_indicators()
for item in season_data:
try:
cm = []
plot = item['overview'] if item['overview'] != '' else meta['plot']
title = item['name'] if use_season_title else 'Season %s' % str(
item['season_number'])
season_poster = "http://image.tmdb.org/t/p/original%s" % item[
'poster_path'] if item['poster_path'] is not None else meta[
'poster']
aired_episodes = aired_episode_number_season(
meta, item['season_number'])
playcount, overlay, watched, unwatched = get_watched_status_season(
meta['tmdb_id'], item['season_number'], aired_episodes)
watched_title = 'Trakt' if watched_indicators in (1, 2) else "Fen"
watched_params = {
"mode": "mark_season_as_watched_unwatched",
"action": 'mark_as_watched',
"title": meta['title'],
"year": meta['year'],
"media_id": meta['tmdb_id'],
"imdb_id": meta["imdb_id"],
"tvdb_id": meta["tvdb_id"],
"season": item['season_number']
}
unwatched_params = {
"mode": "mark_season_as_watched_unwatched",
"action": 'mark_as_unwatched',
"title": meta['title'],
"year": meta['year'],
"media_id": meta['tmdb_id'],
"imdb_id": meta["imdb_id"],
"tvdb_id": meta["tvdb_id"],
"season": item['season_number']
}
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)' %
meta['tmdb_id']))
url_params = {
'mode': 'build_episode_list',
'tmdb_id': meta['tmdb_id'],
'season': str(item['season_number']),
'season_id': item['id']
}
url = build_url(url_params)
listitem = xbmcgui.ListItem(title)
listitem.setProperty('watchedepisodes', str(watched))
listitem.setProperty('unwatchedepisodes', str(unwatched))
listitem.setProperty('totalepisodes', str(item['episode_count']))
listitem.addContextMenuItems(cm)
listitem.setArt({
'poster': season_poster,
'fanart': meta['fanart'],
'banner': meta['banner'],
'clearlogo': meta['clearlogo'],
'landscape': meta['landscape']
})
listitem.setCast(meta['cast'])
listitem.setInfo(
'video', {
'mediatype': 'tvshow',
'trailer': str(meta['trailer']),
'title': meta.get('title'),
'size': '0',
'duration': meta.get('episode_run_time'),
'plot': plot,
'rating': meta.get('rating'),
'premiered': meta.get('premiered'),
'studio': meta.get('studio'),
'year': meta.get('year'),
'genre': meta.get('genre'),
'code': meta.get('imdb_id'),
'tvshowtitle': meta.get('title'),
'imdbnumber': meta.get('imdb_id'),
'votes': meta.get('votes'),
'episode': str(item['episode_count']),
'playcount': playcount,
'overlay': overlay
})
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(__handle__, 'seasons')
xbmcplugin.endOfDirectory(__handle__)
setView('view.seasons')
window.setProperty('fen_media_meta', json.dumps(meta))
'director': director,
'playcount': playcount,
'overlay': overlay
})
if not not_widget:
listitem.setProperty("fen_widget", 'true')
listitem.setProperty("fen_playcount", str(playcount))
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=False)
except:
pass
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__)
setView('view.episodes')
def build_episode(item):
from resources.lib.modules.utils import make_day
def check_for_unaired():
try:
d = first_aired.split('-')
episode_date = date(int(d[0]), int(d[1]), int(d[2]))
except:
episode_date = None
current_adjusted_date = settings.adjusted_datetime()
unaired = False
if not episode_date or current_adjusted_date < episode_date:
unaired = True
