def __init__(self,
source_dict,
debrid_torrents,
debrid_hosters,
internal_scrapers,
prescrape_sources,
display_uncached_torrents,
progress_dialog,
disabled_ignored=False):
self.scrape_provider = 'external'
self.debrid_torrents, self.debrid_hosters = debrid_torrents, debrid_hosters
self.source_dict, self.hostDict = source_dict, self.make_host_dict()
self.internal_scrapers, self.prescrape_sources = internal_scrapers, prescrape_sources
self.display_uncached_torrents = display_uncached_torrents
self.progress_dialog, self.disabled_ignored = progress_dialog, disabled_ignored
self.internal_activated, self.internal_prescraped = len(
self.internal_scrapers) > 0, len(self.prescrape_sources) > 0
self.processed_prescrape, self.scraping_started, self.threads_completed = False, False, False
self.sources, self.final_sources, self.processed_internal_scrapers = [], [], []
self.processed_internal_scrapers_append = self.processed_internal_scrapers.append
self.sleep_time = display_sleep_time()
self.pause_scrape = (self.sleep_time * 1.05) / 1000
self.int_dialog_highlight, self.ext_dialog_highlight = get_setting(
'int_dialog_highlight',
'darkgoldenrod'), get_setting('ext_dialog_highlight', 'dodgerblue')
self.finish_early = get_setting('search.finish.early') == 'true'
self.int_total_format, self.ext_total_format = total_format % (
self.int_dialog_highlight,
'%s'), total_format % (self.ext_dialog_highlight, '%s')
self.timeout = 60 if self.disabled_ignored else int(
get_setting('scrapers.timeout.1', '60'))
self.meta = json.loads(kodi_utils.get_property('fen_playback_meta'))
self.background = self.meta.get('background', False)
self.internal_sources_total = self.internal_sources_4K = self.internal_sources_1080p = self.internal_sources_720p = self.internal_sources_sd = 0
self.sources_total = self.sources_4k = self.sources_1080p = self.sources_720p = self.sources_sd = 0
def get_memory_cache(self, db_type, id_type, media_id, current_time):
result = None
try:
if db_type in ('movie', 'tvshow'):
string = '%s_%s_%s' % (db_type, id_type, media_id)
else:
string = 'meta_season_%s' % str(media_id)
try:
cachedata = get_property(string.encode('utf-8'))
except:
cachedata = get_property(string)
if cachedata:
cachedata = eval(cachedata)
if cachedata[0] > current_time:
result = cachedata[1]
except:
pass
return result
def _process_internal_results(self):
for i in self.internal_scrapers:
win_property = kodi_utils.get_property('%s.internal_results' % i)
if win_property in ('checked', '', None): continue
try:
sources = json.loads(win_property)
except:
continue
kodi_utils.set_property('%s.internal_results' % i, 'checked')
self._sources_quality_count(sources)
def get_setting(setting_id, fallback=None):
try:
settings_dict = json.loads(get_property('fen_settings'))
except:
settings_dict = make_settings_dict()
if settings_dict is None: settings_dict = get_setting_fallback(setting_id)
value = settings_dict.get(setting_id, '')
if fallback is None: return value
if value == '': return fallback
return value
def open_MyAccounts(params):
from myaccounts import openMASettings
query = params.get('query', None)
openMASettings(query)
kodi_utils.sleep(100)
while kodi_utils.get_visibility(
'Window.IsVisible(addonsettings)') or kodi_utils.get_property(
'myaccounts.active') == 'true':
kodi_utils.sleep(250)
kodi_utils.sleep(100)
sync_MyAccounts()
kodi_utils.sleep(100)
open_settings('4.0')
def __init__(self, params):
self.view = 'view.main'
self.db_type = params.get('db_type', None)
self.key = params.get('key', None)
if self.db_type:
self.window_id = 'FEN_%s_discover_params' % self.db_type.upper()
else:
self.window_id = ''
try:
self.discover_params = json.loads(
kodi_utils.get_property(self.window_id))
except:
self.discover_params = {}
self.base_str = '[B]%s:[/B] [I]%s[/I]'
self.include_base_str = '%s %s' % (ls(32188), '%s')
self.exclude_base_str = '%s %s' % (ls(32189), '%s')
self.heading_base = '%s %s - %s' % (ls(32036), ls(32451), '%s')
self.tmdb_api = settings.tmdb_api_key()
def process_internal_results(self):
if self.internal_prescraped and not self.processed_prescrape:
self.process_quality_count(self.prescrape_sources, internal=True)
self.processed_prescrape = True
for i in self.internal_scrapers:
win_property = kodi_utils.get_property('%s.internal_results' % i)
if win_property in ('checked', '', None): continue
try:
internal_sources = json.loads(win_property)
except:
continue
kodi_utils.set_property('%s.internal_results' % i, 'checked')
self.processed_internal_scrapers_append(i)
self.process_quality_count(internal_sources, internal=True)
return [
i for i in self.internal_scrapers
if not i in self.processed_internal_scrapers
]
def resolve_internal_sources(scrape_provider,
item_id,
url_dl,
direct_debrid_link=False):
url = None
try:
if scrape_provider == 'furk':
import json
from indexers.furk import t_file_browser
from modules.source_utils import seas_ep_query_list
from modules.kodi_utils import get_property
meta = json.loads(get_property('fen_playback_meta'))
filtering_list = seas_ep_query_list(
meta['season'],
meta['episode']) if meta['vid_type'] == 'episode' else ''
t_files = t_file_browser(item_id, filtering_list)
url = t_files[0]['url_dl']
elif scrape_provider == 'easynews':
from indexers.easynews import resolve_easynews
url = resolve_easynews({'url_dl': url_dl, 'play': 'false'})
elif scrape_provider == 'rd_cloud':
if direct_debrid_link: return url_dl
from apis.real_debrid_api import RealDebridAPI
url = RealDebridAPI().unrestrict_link(item_id)
elif scrape_provider == 'pm_cloud':
from apis.premiumize_api import PremiumizeAPI
details = PremiumizeAPI().get_item_details(item_id)
url = details['link']
if url.startswith('/'): url = 'https' + url
elif scrape_provider == 'ad_cloud':
from apis.alldebrid_api import AllDebridAPI
url = AllDebridAPI().unrestrict_link(item_id)
elif scrape_provider == 'folders':
if url_dl.endswith('.strm'):
from modules.kodi_utils import open_file
f = open_file(url_dl)
url = f.read()
f.close()
else:
url = url_dl
except:
pass
return url
def trakt_collection_lists(db_type, param1, param2):
# param1 = the type of list to be returned (from 'new_page' param), param2 is currently not used
limit = 20
string_insert = 'movie' if db_type in ('movie', 'movies') else 'tvshow'
window_property_name = 'fen_trakt_collection_%s' % string_insert
try:
data = json.loads(kodi_utils.get_property(window_property_name))
except:
data = trakt_fetch_collection_watchlist('collection', db_type)
if param1 == 'recent':
data.sort(key=lambda k: k['collected_at'], reverse=True)
elif param1 == 'random':
import random
random.shuffle(data)
data = data[:limit]
for item in data:
item['media_id'] = get_trakt_movie_id(
item['media_ids']) if db_type == 'movies' else get_trakt_tvshow_id(
item['media_ids'])
return data, 1
def _confirm_threshold():
nextep_threshold = nextep_settings['threshold']
if nextep_threshold == 0: return True
try:
current_number = int(
kodi_utils.get_property('fen_total_autoplays'))
except:
current_number = 1
if current_number == nextep_threshold:
current_number = 1
kodi_utils.set_property('fen_total_autoplays', str(current_number))
if open_window(('windows.next_episode', 'NextEpisode'),
'next_episode.xml',
meta=nextep_meta,
function='confirm'):
return True
else:
kodi_utils.notification(32736, 1500)
return False
else:
current_number += 1
kodi_utils.set_property('fen_total_autoplays', str(current_number))
return True
def _get_property(setting_id):
return kodi_utils.get_property(
'fen_%s' % setting_id) or get_setting(setting_id)
def _get_nextep_url():
Sources().playback_prep(nextep_params)
return kodi_utils.get_property('fen_nextep_url')
def check_trakt_refresh():
if kodi_utils.get_property('fen_refresh_trakt_info') == 'true':
from apis.trakt_api import trakt_sync_activities
trakt_sync_activities(force_update=True)
kodi_utils.clear_property('fen_refresh_trakt_info')
def get_home_property(self, prop):
return kodi_utils.get_property('fen.home_window.%s' % prop)
def browse_audio_album(t_files, item_path=None):
def build_list_object():
try:
cm = []
url_params = {
'mode': 'media_play',
'url': item['url_dl'],
'media_type': 'music'
}
url = build_url(url_params)
track_name = clean_file_name(
batch_replace(to_utf8(item['name']), formats)).upper()
listitem = make_listitem()
listitem.setLabel(track_name)
down_file_params = {
'mode': 'downloader',
'name': item['name'],
'url': item['url_dl'],
'action': 'audio',
'image': default_furk_icon
}
cm.append(
(ls(32747), 'RunPlugin(%s)' % build_url(down_file_params)))
listitem.addContextMenuItems(cm)
listitem.setArt({
'icon': default_furk_icon,
'poster': default_furk_icon,
'thumb': default_furk_icon,
'fanart': fanart,
'banner': default_furk_icon
})
kodi_utils.add_item(__handle__, url, listitem, True)
except:
pass
from modules.utils import batch_replace
__handle__ = int(argv[1])
seperate = False
if not t_files:
seperate = True
t_fs = kodi_utils.get_property('furk_t_files_json')
t_files = json.loads(t_fs)
t_files = [i for i in t_files if 'audio' in i['ct']]
line = '%s[CR]%s[CR]%s'
if seperate:
if kodi_utils.confirm_dialog(text=32763,
ok_label=32838,
cancel_label=32764,
top_space=True):
for item in t_files:
t_path = clean_file_name(item['path'])
if t_path == item_path:
build_list_object()
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')
else:
from modules.player import FenPlayer
FenPlayer().playAudioAlbum(t_files, from_seperate=True)
else:
for item in t_files:
build_list_object()
kodi_utils.set_content(__handle__, 'files')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.premium')