def search_furk(params):
from modules.history import add_to_search_history
__handle__ = int(argv[1])
search_title = clean_file_name(params.get('query')) if (
'query' in params and params.get('query') != 'NA') else None
if not search_title: search_title = kodi_utils.dialog.input('Fen')
try:
search_name = clean_file_name(unquote(search_title))
search_method = 'search' if 'accurate_search' in params else 'direct_search'
search_setting = 'furk_video_queries' if params.get(
'db_type') == 'video' else 'furk_audio_queries'
list_type = 'video' if params.get('db_type') == 'video' else 'audio'
add_to_search_history(search_name, search_setting)
files = Furk.direct_search(
search_name) if search_method == 'direct_search' else Furk.search(
search_name)
if not files: return kodi_utils.ok_dialog(text=32760, top_space=True)
try:
files = [
i for i in files
if i.get('is_ready', '0') == '1' and i['type'] == list_type
]
except:
return kodi_utils.ok_dialog(text=32760, top_space=True)
furk_file_browser(files, params, 'search', __handle__)
except:
pass
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def 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 furk_tfile_audio(params):
__handle__ = int(argv[1])
kodi_utils.clear_property('furk_t_files_json')
excludes = ('', 'cover', 'covers', 'scan', 'scans', 'playlists')
t_files = Furk.t_files(params.get('item_id'))
item_path_list = list(
set([
clean_file_name(i['path']) for i in t_files
if clean_file_name(i['path']).lower() not in excludes
]))
item_path_list.sort()
line = '%s[CR]%s[CR]%s'
if not item_path_list:
if kodi_utils.confirm_dialog(text=32763,
ok_label=32652,
cancel_label=32764,
top_space=True):
return browse_audio_album(t_files, params.get('name'))
from modules.player import FenPlayer
FenPlayer().playAudioAlbum(t_files)
return browse_audio_album(t_files, __handle__)
def _builder():
for x in item_path_list:
try:
url_params = {
'mode': 'furk.browse_audio_album',
'item_path': x,
'handle': __handle__
}
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(x.upper())
listitem.setArt({
'icon': default_furk_icon,
'poster': default_furk_icon,
'thumb': default_furk_icon,
'fanart': fanart,
'banner': default_furk_icon
})
yield (url, listitem, True)
except:
pass
t_files_json = json.dumps(t_files)
kodi_utils.set_property('furk_t_files_json', str(t_files_json))
kodi_utils.add_items(__handle__, list(_builder()))
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def furkPacks(self, name, file_id, highlight=None, download=False):
from apis.furk_api import FurkAPI
kodi_utils.show_busy_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]
t_files.sort(key=lambda k: k['name'].lower())
kodi_utils.hide_busy_dialog()
if download: return t_files
default_furk_icon = kodi_utils.translate_path(
'special://home/addons/script.tikiart/resources/media/furk.png')
list_items = [{
'line1':
'%.2f GB | %s' % (float(item['size']) / 1073741824,
clean_file_name(item['name']).upper()),
'icon':
default_furk_icon
} for item in t_files]
kwargs = {
'items': json.dumps(list_items),
'heading': name,
'highlight': highlight,
'enumerate': 'true',
'multi_choice': 'false',
'multi_line': 'false'
}
chosen_result = kodi_utils.select_dialog(t_files, **kwargs)
if chosen_result is None: return None
link = chosen_result['url_dl']
name = chosen_result['name']
return FenPlayer().run(link, 'video')
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 results(self, info):
try:
self.title = info.get('title')
self.search_title = clean_file_name(self.title).replace('&', 'and')
self.db_type = info.get('db_type')
self.year = info.get('year')
self.season = info.get('season')
self.episode = info.get('episode')
search_name = self._search_name()
files = EasyNews.search(search_name)
if not files:
return internal_results(self.scrape_provider, self.sources)
self.aliases = get_aliases_titles(info.get('aliases', []))
def _process():
for item in files:
try:
file_name = normalize(item['name'])
if self.title_filter and not check_title(
self.title, file_name, self.aliases, self.year,
self.season, self.episode):
continue
if self.filter_lang and not any(
i in self.lang_filters
for i in item['language']):
continue
URLName = clean_file_name(file_name).replace(
'html', ' ').replace('+', ' ').replace('-', ' ')
url_dl = item['url_dl']
size = round(
float(int(item['rawSize'])) / 1073741824, 2)
video_quality, details = get_file_info(
name_info=release_info_format(file_name))
source_item = {
'name': file_name,
'title': file_name,
'URLName': URLName,
'quality': video_quality,
'size': size,
'size_label': '%.2f GB' % size,
'extraInfo': details,
'url_dl': url_dl,
'id': url_dl,
'local': False,
'direct': True,
'source': self.scrape_provider,
'scrape_provider': self.scrape_provider
}
yield source_item
except Exception as e:
from modules.kodi_utils import logger
logger('FEN easynews scraper yield source error',
str(e))
self.sources = list(_process())
except Exception as e:
from modules.kodi_utils import logger
logger('FEN easynews scraper Exception', str(e))
internal_results(self.scrape_provider, self.sources)
return self.sources
def _process():
for item in self.scrape_results:
try:
file_name = normalize(item['name'])
if self.title_filter:
if not check_title(self.title, file_name,
self.aliases, self.year,
self.season, self.episode):
continue
URLName = clean_file_name(file_name).replace(
'html', ' ').replace('+', ' ').replace('-', ' ')
path = item['path']
file_dl = item['id']
size = round(float(item['size']) / 1073741824, 2)
video_quality, details = get_file_info(
name_info=release_info_format(file_name))
source_item = {
'name': file_name,
'title': file_name,
'URLName': URLName,
'quality': video_quality,
'size': size,
'size_label': '%.2f GB' % size,
'extraInfo': details,
'url_dl': file_dl,
'id': file_dl,
'downloads': False,
'direct': True,
'source': self.scrape_provider,
'scrape_provider': self.scrape_provider
}
yield source_item
except:
pass
def build_list_object():
try:
cm = []
url_params = {
'mode': 'media_play',
'url': item['url_dl'],
'media_type': 'music'
}
url = build_url(url_params)
track_name = clean_file_name(
batch_replace(to_utf8(item['name']), formats)).upper()
listitem = make_listitem()
listitem.setLabel(track_name)
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': item['url_dl'],
'action': 'audio',
'image': default_furk_icon
}
cm.append(
(ls(32747), 'RunPlugin(%s)' % build_url(down_file_params)))
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_furk_icon,
'poster': default_furk_icon,
'thumb': default_furk_icon,
'fanart': fanart,
'banner': default_furk_icon
})
kodi_utils.add_item(__handle__, url, listitem, True)
except:
pass
def _process():
for item in self.scrape_results:
try:
file_name = normalize(item[0])
if self.title_filter:
if not check_title(self.title, file_name, self.aliases, self.year, self.season, self.episode): continue
file_dl = item[1]
URLName = clean_file_name(file_name).replace('html', ' ').replace('+', ' ').replace('-', ' ')
try: size = item[2]
except: size = self._get_size(file_dl)
video_quality, details = get_file_info(name_info=release_info_format(file_name))
source_item = {'name': file_name,
'title': file_name,
'URLName': URLName,
'quality': video_quality,
'size': size,
'size_label': '%.2f GB' % size,
'extraInfo': details,
'url_dl': file_dl,
'id': file_dl,
self.scrape_provider : True,
'direct': True,
'source': self.scraper_name,
'scrape_provider': 'folders'}
yield source_item
except: pass
def _builder():
for count, item in enumerate(my_cloud_files, 1):
try:
cm = []
cm_append = cm.append
folder_name = item['filename']
normalized_folder_name = normalize(folder_name)
string = 'FEN_RD_%s' % normalized_folder_name
link_folders_add = {
'mode': 'link_folders',
'service': 'RD',
'folder_name': normalized_folder_name,
'action': 'add'
}
link_folders_remove = {
'mode': 'link_folders',
'service': 'RD',
'folder_name': normalized_folder_name,
'action': 'remove'
}
current_link = main_cache.get(string)
if current_link:
ending = '[COLOR=limegreen][B][I]\n %s[/I][/B][/COLOR]' % (
linkedto_str % current_link)
else:
ending = ''
display = '%02d | [B]%s[/B] | [I]%s [/I]%s' % (
count, folder_str,
clean_file_name(normalized_folder_name).upper(), ending)
url_params = {
'mode': 'real_debrid.browse_rd_cloud',
'id': item['id']
}
delete_params = {
'mode': 'real_debrid.delete',
'id': item['id'],
'cache_type': 'torrent'
}
url = build_url(url_params)
cm_append(
('[B]%s %s[/B]' % (delete_str, folder_str.capitalize()),
'RunPlugin(%s)' % build_url(delete_params)))
cm_append((addlink_str,
'RunPlugin(%s)' % build_url(link_folders_add)))
cm_append((clearlink_str,
'RunPlugin(%s)' % build_url(link_folders_remove)))
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_rd_icon,
'poster': default_rd_icon,
'thumb': default_rd_icon,
'fanart': fanart,
'banner': default_rd_icon
})
yield (url, listitem, True)
except:
pass
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 search_easynews(params):
from modules.history import add_to_search_history
__handle__ = int(argv[1])
search_title = clean_file_name(params.get('query')) if (
'query' in params and params.get('query') != 'NA') else None
if not search_title:
search_title = kodi_utils.dialog.input('Enter search Term')
try:
if search_title:
search_name = clean_file_name(unquote(search_title))
add_to_search_history(search_name, 'easynews_video_queries')
files = EasyNews.search(search_name)
if not files:
return kodi_utils.ok_dialog(text=32760, top_space=True)
easynews_file_browser(files, __handle__)
except:
pass
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
def get_library_video(db_type, title, year, season=None, episode=None):
import xbmcvfs
try:
years = (year, str(int(year) + 1), str(int(year) - 1))
if db_type == 'movie':
r = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"filter":{"or": [{"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}]}, "properties": ["imdbnumber", "title", "originaltitle", "file"]}, "id": 1}'
% years)
r = to_utf8(r)
r = json.loads(r)['result']['movies']
try:
r = [
i for i in r
if clean_file_name(title).lower() in clean_file_name(
to_utf8(i['title'])).lower()
]
except:
return None
r = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovieDetails", "params": {"properties": ["streamdetails", "file"], "movieid": %s }, "id": 1}'
% str(r['movieid']))
r = to_utf8(r)
r = json.loads(r)['result']['moviedetails']
elif db_type == 'tvshow':
r = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"filter":{"or": [{"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}]}, "properties": ["title", "year"]}, "id": 1}'
% years)
r = to_utf8(r)
r = json.loads(r)['result']['tvshows']
try:
r = [
i for i in r if clean_file_name(title).lower() in (
clean_file_name(to_utf8(i['title'])).lower() if
not ' (' in to_utf8(i['title']) else clean_file_name(
to_utf8(i['title'])).lower().split(' (')[0])
][0]
return r
except:
return None
except:
pass
def process_sources(self, provider, sources):
try:
for i in sources:
try:
if 'hash' in i:
_hash = i['hash'].lower()
i['hash'] = str(_hash)
size, size_label, divider = 0, None, None
if 'name' in i:
URLName = clean_file_name(i['name']).replace(
'html', ' ').replace('+', ' ').replace('-', ' ')
else:
URLName = source_utils.get_filename_match(
self.orig_title, i['url'], i.get('name', None))
if 'name_info' in i:
quality, extraInfo = source_utils.get_file_info(
name_info=i['name_info'])
else:
quality, extraInfo = source_utils.get_file_info(
url=i['url'])
try:
size = i['size']
if 'package' in i and provider != 'torrentio':
if i['package'] == 'season':
divider = [
int(x['episode_count'])
for x in self.meta['season_data']
if int(x['season_number']) == int(
self.meta['season'])
][0]
else:
divider = int(self.meta['total_aired_eps'])
size = float(size) / divider
size_label = '%.2f GB' % size
else:
size_label = '%.2f GB' % size
except:
pass
i.update({
'provider': provider,
'external': True,
'scrape_provider': self.scrape_provider,
'extraInfo': extraInfo,
'URLName': URLName,
'quality': quality,
'size_label': size_label,
'size': round(size, 2)
})
except:
pass
except:
pass
return sources
def _search_name(self):
search_title = clean_file_name(self.info.get("title"))
db_type = self.info.get("db_type")
year = self.info.get("year")
years = '%s,%s,%s' % (str(int(year - 1)), year, str(int(year + 1)))
season = self.info.get("season")
episode = self.info.get("episode")
if db_type == 'movie': search_name = '"%s" %s' % (search_title, years)
else:
search_name = '%s S%02dE%02d' % (search_title, int(season),
int(episode))
return search_name
def debridPacks(self,
debrid_provider,
name,
magnet_url,
info_hash,
highlight=None,
download=False):
if debrid_provider == 'Real-Debrid':
from apis.real_debrid_api import RealDebridAPI as debrid_function
icon = 'realdebrid.png'
elif debrid_provider == 'Premiumize.me':
from apis.premiumize_api import PremiumizeAPI as debrid_function
icon = 'premiumize.png'
elif debrid_provider == 'AllDebrid':
from apis.alldebrid_api import AllDebridAPI as debrid_function
icon = 'alldebrid.png'
kodi_utils.show_busy_dialog()
try:
debrid_files = debrid_function().display_magnet_pack(
magnet_url, info_hash)
except:
debrid_files = None
kodi_utils.hide_busy_dialog()
if not debrid_files: return kodi_utils.notification(32574)
debrid_files.sort(key=lambda k: k['filename'].lower())
if download: return debrid_files, debrid_function
default_debrid_icon = kodi_utils.translate_path(
'special://home/addons/script.tikiart/resources/media/%s' % icon)
list_items = [{
'line1':
'%.2f GB | %s' % (float(item['size']) / 1073741824,
clean_file_name(item['filename']).upper()),
'icon':
default_debrid_icon
} for item in debrid_files]
kwargs = {
'items': json.dumps(list_items),
'heading': name,
'highlight': highlight,
'enumerate': 'true',
'multi_choice': 'false',
'multi_line': 'false'
}
chosen_result = kodi_utils.select_dialog(debrid_files, **kwargs)
if chosen_result is None: return None
url_dl = chosen_result['link']
if debrid_provider in ('Real-Debrid', 'AllDebrid'):
link = debrid_function().unrestrict_link(url_dl)
elif debrid_provider == 'Premiumize.me':
link = debrid_function().add_headers_to_url(url_dl)
name = chosen_result['filename']
return FenPlayer().run(link, 'video')
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 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
def get_filename_match(title, url, name=None):
from modules.utils import clean_file_name
if name: return clean_file_name(name)
from modules.utils import clean_title, normalize
title_match = None
try:
title = clean_title(normalize(title))
name_url = unquote(url)
try:
file_name = clean_title(name_url.split('/')[-1])
except:
return title_match
test = name_url.split('/')
for item in test:
test_url = string(clean_title(normalize(item)))
if title in test_url:
title_match = clean_file_name(string(item)).replace(
'html', ' ').replace('+', ' ')
break
except:
pass
return title_match
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 add_trakt_subscription_listitem(self, db_type, ids, count, total, path,
dialog):
try:
get_ids = get_trakt_movie_id if db_type in (
'movie', 'movies') else get_trakt_tvshow_id
meta_action = tikimeta.movie_meta if db_type in (
'movie', 'movies') else tikimeta.tvshow_meta
tmdb_id = get_ids(ids)
address_insert = 'movie' if db_type in ('movie',
'movies') else 'tv'
meta = meta_action('tmdb_id', tmdb_id, self.meta_user_info)
title = clean_file_name(meta['title'])
year = meta['year'] if 'year' in meta else '0'
rootname = '{0} ({1})'.format(title,
year) if year != '0' else title
folder = os.path.join(path, rootname + '/')
nfo_filename = rootname + '.nfo' if db_type in (
'movie', 'movies') else 'tvshow.nfo'
nfo_filepath = os.path.join(folder, nfo_filename)
nfo_content = "https://www.themoviedb.org/%s/%s-%s" % (
address_insert, str(meta['tmdb_id']), title.lower().replace(
' ', '-'))
self.make_folder(folder)
self.make_nfo(nfo_filepath, nfo_content)
if db_type in ('movie', 'movies'):
in_library = get_library_video(
'movie', title,
year) if settings.skip_duplicates() else False
if in_library: return
stream_file = self.create_movie_strm_files(folder, rootname)
params = to_utf8({
'mode': 'play_media',
'library': 'True',
'query': rootname,
'poster': meta['poster'],
'year': year,
'plot': meta['plot'],
'title': title,
'tmdb_id': meta['tmdb_id'],
'vid_type': 'movie'
})
self.make_stream(stream_file, params)
else:
self.create_tvshow_strm_files(meta, folder, tmdb_id, title,
year)
dialog.update(int(float(count) / float(total) * 100), '',
'Adding: [B]%s[/B]' % rootname)
except Exception as e:
logger('add_trakt_subscription_listitem Exception', e)
pass
def _builder():
for count, item in enumerate(my_downloads, 1):
try:
cm = []
cm_append = cm.append
datetime_object = jsondate_to_datetime(item['generated'],
'%Y-%m-%dT%H:%M:%S.%fZ',
remove_time=True)
filename = item['filename']
name = clean_file_name(filename).upper()
size = float(int(item['filesize'])) / 1073741824
display = '%02d | %.2f GB | %s | [I]%s [/I]' % (
count, size, datetime_object, name)
url_link = item['download']
url_params = {
'mode': 'media_play',
'url': url_link,
'media_type': 'video'
}
down_file_params = {
'mode': 'downloader',
'name': name,
'url': url_link,
'action': 'cloud.realdebrid_direct',
'image': default_rd_icon
}
delete_params = {
'mode': 'real_debrid.delete',
'id': item['id'],
'cache_type': 'download'
}
cm_append(
(down_str, 'RunPlugin(%s)' % build_url(down_file_params)))
cm_append(
('[B]%s %s[/B]' % (delete_str, file_str.capitalize()),
'RunPlugin(%s)' % build_url(delete_params)))
url = build_url(url_params)
listitem = make_listitem()
listitem.setLabel(display)
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_rd_icon,
'poster': default_rd_icon,
'thumb': default_rd_icon,
'fanart': fanart,
'banner': default_rd_icon
})
yield (url, listitem, True)
except:
pass
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 select_pack_item(pack_choices, highlight, icon):
list_items = [{'line1': '%.2f GB | %s' % (float(item['pack_files']['size'])/1073741824, clean_file_name(item['pack_files']['filename']).upper()), 'icon': icon} \
for item in pack_choices]
heading = '%s - %s' % (
ls(32031),
clean_file_name(json.loads(pack_choices[0].get('source')).get('name')))
kwargs = {
'items': json.dumps(list_items),
'heading': heading,
'highlight': highlight,
'enumerate': 'true',
'multi_choice': 'true',
'multi_line': 'false'
}
return kodi_utils.select_dialog(pack_choices, **kwargs)
def add_remove_constants(self):
meta_action = tikimeta.movie_meta if self.db_type == 'movie' else tikimeta.tvshow_meta
address_insert = 'movie' if self.db_type == 'movie' else 'tv'
self.meta = meta_action('tmdb_id', self.tmdb_id, self.meta_user_info)
self.title = clean_file_name(self.meta['title'])
self.year = self.meta['year'] if 'year' in self.meta else ''
self.rootname = '{0} ({1})'.format(
self.title, self.year) if self.year else self.title
self.folder = os.path.join(self.path, self.rootname + '/')
self.nfo_filename = self.rootname + '.nfo' if self.db_type == 'movie' else 'tvshow.nfo'
self.nfo_filepath = os.path.join(self.folder, self.nfo_filename)
self.nfo_content = "https://www.themoviedb.org/%s/%s-%s" % (
address_insert, str(
self.meta['tmdb_id']), self.title.lower().replace(' ', '-'))
self.notify = '[B]%s[/B] added to Subscriptions' if self.action == 'add' else '[B]%s[/B] removed from Subscriptions'
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 remove_trakt_subscription_listitem(self, db_type, media_id, count,
total, path, dialog):
try:
meta_action = tikimeta.movie_meta if db_type in (
'movie', 'movies') else tikimeta.tvshow_meta
tmdb_id = media_id
meta = meta_action('tmdb_id', tmdb_id, self.meta_user_info)
title = clean_file_name(meta['title'])
year = meta['year'] if 'year' in meta else ''
rootname = '{0} ({1})'.format(title, year) if year else title
folder = os.path.join(path, rootname + '/')
self.remove_folder(folder)
dialog.update(int(float(count) / float(total) * 100),
'Please Wait...', 'Removing: [B]%s[/B]' % rootname)
except:
pass
def play_trailer(url, all_trailers=[]):
if all_trailers:
import xbmcgui
import json
from modules.utils import clean_file_name, to_utf8
all_trailers = to_utf8(json.loads(all_trailers))
video_choice = xbmcgui.Dialog().select(
"Youtube Videos...",
[clean_file_name(i['name']) for i in all_trailers])
if video_choice < 0: return
url = 'plugin://plugin.video.youtube/play/?video_id=%s' % all_trailers[
video_choice].get('key')
try:
xbmc.executebuiltin('RunPlugin(%s)' % url)
except:
notification('Error Playing Trailer')
def _search_name(self):
search_title = clean_file_name(to_utf8(self.info.get("title")))
search_title = search_title.replace(' ', '+')
db_type = self.info.get("db_type")
if db_type == 'movie':
year = self.info.get("year")
years = '%s+|+%s+|+%s' % (str(
int(year - 1)), year, str(int(year + 1)))
search_name = '@name+%s+%s' % (search_title, years)
else:
season = self.info.get("season")
episode = self.info.get("episode")
queries = self._seas_ep_query_list(season, episode)
search_name = '@name+%s+@files+%s+|+%s+|+%s+|+%s+|+%s' % (
search_title, queries[0], queries[1], queries[2], queries[3],
queries[4])
return search_name
