def get_language():
try:
language = xbmc.getLanguage(xbmc.ISO_639_1, True)
languageParts = language.split("-")
return "{}_{}.UTF-8".format(languageParts[0], languageParts[1])
except:
return ""
def parse_payload(method, payload):
if method == 'general':
if 'query' in payload:
payload['title'] = payload['query']
payload['titles'] = {'source': payload['query']}
else:
payload = {
'title': payload,
'titles': {
'source': payload
},
}
payload['titles'] = dict(
(k.lower(), v) for k, v in payload['titles'].iteritems())
if get_setting('kodi_language', bool):
kodi_language = xbmc.getLanguage(xbmc.ISO_639_1)
if not kodi_language:
log.warning("Kodi returned empty language code...")
elif kodi_language not in payload.get('titles', {}):
log.info("No '%s' translation available..." % kodi_language)
else:
payload["search_title"] = payload["titles"][kodi_language]
if "search_title" not in payload:
log.info(
"Could not determine search title, falling back to normal title: %s",
repr(payload["title"]))
payload["search_title"] = payload["title"]
return payload
def top_level_page():
"""The main menu, media categories from tv.jw.org plus extra stuff"""
default_fanart = os.path.join(addon.getAddonInfo('path'),
addon.getAddonInfo('fanart'))
if addon.getSetting(SettingID.START_WARNING) == 'true':
dialog = xbmcgui.Dialog()
try:
dialog.textviewer(S.THEO_WARN, S.DISCLAIMER) # Kodi v16
except AttributeError:
dialog.ok(S.THEO_WARN, S.DISCLAIMER)
addon.setSetting(SettingID.START_WARNING, 'false')
# Auto language
isolang = xbmc.getLanguage(xbmc.ISO_639_1)
if not addon.getSetting(SettingID.LANG_HIST):
# Write English to language history, so this code only runs once
addon.setSetting(SettingID.LANG_HIST, 'E')
# If Kodi is in foreign language
if isolang != 'en':
data = get_json(LANGUAGE_URL + 'E/web')
for l in data['languages']:
if l['locale'] == isolang:
# Save setting, and update for this this instance
set_language(l['code'],
l['name'] + ' / ' + l['vernacular'])
global global_lang
global_lang = addon.getSetting(SettingID.LANGUAGE) or 'E'
break
data = get_json(CATEGORY_URL + global_lang + '?detailed=True')
for c in data['categories']:
d = Directory(fanart=default_fanart)
d.parse_category(c)
if d.url and not d.hidden:
d.add_item_in_kodi()
# Get "search" translation from internet - overkill but so cool
# Try cache first, to speed up loading
search_label = addon.getSetting(SettingID.SEARCH_TRANSL)
if not search_label:
data = get_json(TRANSLATION_URL + global_lang, ignore_errors=True)
search_label = getitem(data,
'translations',
global_lang,
'hdgSearch',
default='Search')
addon.setSetting(SettingID.SEARCH_TRANSL, search_label)
d = Directory(url=request_to_self({Q.MODE: M.SEARCH}),
title=search_label,
fanart=default_fanart,
icon='DefaultMusicSearch.png')
d.add_item_in_kodi()
xbmcplugin.endOfDirectory(addon_handle)
def __getattr__(self, name):
if name in ['MOVIE_PATH', 'TV_SHOWS_PATH']:
export = self._g.DATA_PATH
if self._gs('enablelibraryfolder') == 'true':
export = py2_decode(xbmc.translatePath(self._gs('customlibraryfolder')))
export = OSPJoin(export, 'Movies' if 'MOVIE_PATH' == name else 'TV')
return export + '\\' if '\\' in export else export + '/'
elif 'Language' == name:
# Language settings
l = jsonRPC('Settings.GetSettingValue', param={'setting': 'locale.audiolanguage'})
l = xbmc.convertLanguage(l['value'], xbmc.ISO_639_1)
l = l if l else xbmc.getLanguage(xbmc.ISO_639_1, False)
return l if l else 'en'
elif 'playMethod' == name: return int(self._gs('playmethod'))
elif 'browser' == name: return int(self._gs('browser'))
elif 'MaxResults' == name: return int(self._gs('items_perpage'))
elif 'tvdb_art' == name: return self._gs('tvdb_art')
elif 'tmdb_art' == name: return self._gs('tmdb_art')
elif 'showfanart' == name: return self._gs('useshowfanart') == 'true'
elif 'dispShowOnly' == name: return self._gs('disptvshow') == 'true'
elif 'payCont' == name: return self._gs('paycont') == 'true'
elif 'verbLog' == name: return self._gs('logging') == 'true'
elif 'useIntRC' == name: return self._gs('remotectrl') == 'true'
elif 'RMC_vol' == name: return self._gs('remote_vol') == 'true'
elif 'ms_mov' == name: ms_mov = self._gs('mediasource_movie'); return ms_mov if ms_mov else 'Amazon Movies'
elif 'ms_tv' == name: ms_tv = self._gs('mediasource_tv'); return ms_tv if ms_tv else 'Amazon TV'
elif 'multiuser' == name: return self._gs('multiuser') == 'true'
elif 'DefaultFanart' == name: return OSPJoin(self._g.PLUGIN_PATH, 'fanart.png')
elif 'ThumbIcon' == name: return OSPJoin(self._g.PLUGIN_PATH, 'resources', 'thumb.png')
elif 'NextIcon' == name: return OSPJoin(self._g.PLUGIN_PATH, 'resources', 'next.png')
elif 'HomeIcon' == name: return OSPJoin(self._g.PLUGIN_PATH, 'resources', 'home.png')
elif 'wl_order' == name: return ['DATE_ADDED_DESC', 'TITLE_DESC', 'TITLE_ASC'][int('0' + self._gs('wl_order'))]
elif 'verifySsl' == name: return self._gs('ssl_verif') == 'false'
elif 'OfferGroup' == name: return '' if self.payCont else '&OfferGroups=B0043YVHMY'
elif 'wl_export' == name: return self._gs('wl_export') == 'true'
elif 'region' == name: return int(self._gs('region'))
elif 'proxyaddress' == name: return getConfig('proxyaddress')
elif 'subtitleStretch' == name: return self._gs('sub_stretch') == 'true'
elif 'subtitleStretchFactor' == name:
return [24 / 23.976, 23.976 / 24, 25 / 23.976, 23.976 / 25, 25.0 / 24.0, 24.0 / 25.0][int(self._gs('sub_stretch_factor'))]
elif 'audioDescriptions' == name: return self._gs('audio_description') == 'true'
elif 'removePosters' == name: return self._gs('pv_episode_thumbnails') == 'true'
elif 'useEpiThumbs' == name: return self._gs('tld_episode_thumbnails') == 'true'
elif 'bypassProxy' == name: return self._gs('proxy_mpdalter') == 'false'
elif 'uhdAndroid' == name: return self._gs('uhd_android') == 'true'
elif 'skip_scene' == name: return int('0' + self._gs('skip_scene'))
elif 'pagination' == name: return {
'all': self._gs('paginate_everything') == 'true',
'watchlist': self._gs('paginate_watchlist') == 'true',
'collections': self._gs('paginate_collections') == 'true',
'search': self._gs('paginate_search') == 'true'
}
def apiLanguage(ret_name=None):
langDict = {
'Bulgarian': 'bg', 'Chinese': 'zh', 'Croatian': 'hr', 'Czech': 'cs', 'Danish': 'da', 'Dutch': 'nl',
'English': 'en', 'Finnish': 'fi', 'French': 'fr', 'German': 'de', 'Greek': 'el', 'Hebrew': 'he',
'Hungarian': 'hu', 'Italian': 'it', 'Japanese': 'ja', 'Korean': 'ko', 'Norwegian': 'no', 'Polish': 'pl',
'Portuguese': 'pt', 'Romanian': 'ro', 'Russian': 'ru', 'Serbian': 'sr', 'Slovak': 'sk', 'Slovenian': 'sl',
'Spanish': 'es', 'Swedish': 'sv', 'Thai': 'th', 'Turkish': 'tr', 'Ukrainian': 'uk'}
trakt = ['bg', 'cs', 'da', 'de', 'el', 'en', 'es', 'fi', 'fr', 'he', 'hr', 'hu', 'it', 'ja',
'ko', 'nl', 'no', 'pl', 'pt', 'ro', 'ru', 'sk', 'sl', 'sr', 'sv', 'th', 'tr', 'uk', 'zh']
tvdb = ['en', 'sv', 'no', 'da', 'fi', 'nl', 'de', 'it', 'es', 'fr', 'pl',
'hu', 'el', 'tr', 'ru', 'he', 'ja', 'pt', 'zh', 'cs', 'sl', 'hr', 'ko']
youtube = ['gv', 'gu', 'gd', 'ga', 'gn', 'gl', 'ty', 'tw', 'tt', 'tr', 'ts', 'tn', 'to', 'tl', 'tk', 'th', 'ti',
'tg', 'te', 'ta', 'de', 'da', 'dz', 'dv', 'qu', 'zh', 'za', 'zu', 'wa', 'wo', 'jv', 'ja', 'ch', 'co',
'ca', 'ce', 'cy', 'cs', 'cr', 'cv', 'cu', 'ps', 'pt', 'pa', 'pi', 'pl', 'mg', 'ml', 'mn', 'mi', 'mh',
'mk', 'mt', 'ms', 'mr', 'my', 've', 'vi', 'is', 'iu', 'it', 'vo', 'ii', 'ik', 'io', 'ia', 'ie', 'id',
'ig', 'fr', 'fy', 'fa', 'ff', 'fi', 'fj', 'fo', 'ss', 'sr', 'sq', 'sw', 'sv', 'su', 'st', 'sk', 'si',
'so', 'sn', 'sm', 'sl', 'sc', 'sa', 'sg', 'se', 'sd', 'lg', 'lb', 'la', 'ln', 'lo', 'li', 'lv', 'lt',
'lu', 'yi', 'yo', 'el', 'eo', 'en', 'ee', 'eu', 'et', 'es', 'ru', 'rw', 'rm', 'rn', 'ro', 'be', 'bg',
'ba', 'bm', 'bn', 'bo', 'bh', 'bi', 'br', 'bs', 'om', 'oj', 'oc', 'os', 'or', 'xh', 'hz', 'hy', 'hr',
'ht', 'hu', 'hi', 'ho', 'ha', 'he', 'uz', 'ur', 'uk', 'ug', 'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an',
'as', 'ar', 'av', 'ay', 'az', 'nl', 'nn', 'no', 'na', 'nb', 'nd', 'ne', 'ng', 'ny', 'nr', 'nv', 'ka',
'kg', 'kk', 'kj', 'ki', 'ko', 'kn', 'km', 'kl', 'ks', 'kr', 'kw', 'kv', 'ku', 'ky']
name = None
name = setting('api.language')
if not name:
name = 'AUTO'
if name[-1].isupper():
try:
name = xbmc.getLanguage(xbmc.ENGLISH_NAME).split(' ')[0]
except Exception:
pass
try:
name = langDict[name]
except Exception:
name = 'en'
lang = {'trakt': name} if name in trakt else {'trakt': 'en'}
lang['tvdb'] = name if name in tvdb else 'en'
lang['youtube'] = name if name in youtube else 'en'
if ret_name:
lang['trakt'] = [i[0] for i in six.iteritems(langDict)if i[1] == lang['trakt']][0]
lang['tvdb'] = [i[0] for i in six.iteritems(langDict) if i[1] == lang['tvdb']][0]
lang['youtube'] = [i[0] for i in six.iteritems(langDict) if i[1] == lang['youtube']][0]
return lang
def top_level_page():
"""The main menu"""
if addon.getSetting(SettingID.STARTUP_MSG) == 'true':
dialog = xbmcgui.Dialog()
try:
dialog.textviewer(S.THEO_WARN, S.DISCLAIMER) # Kodi v16
except AttributeError:
dialog.ok(S.THEO_WARN, S.DISCLAIMER)
addon.setSetting(SettingID.STARTUP_MSG, 'false')
# Auto set language, if it has never been set and Kodi is configured for something else then English
isolang = xbmc.getLanguage(xbmc.ISO_639_1)
if not addon.getSetting(SettingID.LANG_HIST) and isolang != 'en':
try:
# Search for matching language, save setting (and update translations)
language_dialog(preselect=isolang)
# Reload for this instance
global global_language
global_language = addon.getSetting(SettingID.LANG) or 'E'
except StopIteration:
# No suitable language was found, just write something to history, so this check won't run again
addon.setSetting(SettingID.LANG_HIST, 'E')
fanart = os.path.join(addon.getAddonInfo('path'), addon.getAddonInfo('fanart'))
MenuItem(
url=request_to_self(M.BIBLE),
title=T.BIBLE or S.BIBLE,
icon=ICON_BIBLE,
fanart=fanart
).add_item_in_kodi()
MenuItem(
url=request_to_self(M.MAGAZINES),
title=T.MAGAZINES or S.MAGAZINES,
icon=ICON_WATCHTOWER,
fanart=fanart
).add_item_in_kodi()
MenuItem(
url=request_to_self(M.BOOKS),
title=T.BOOKS or S.BOOKS,
icon=ICON_BOOKS,
fanart=fanart
).add_item_in_kodi()
xbmcplugin.endOfDirectory(addon_handle)
def GetLanguage(self, *args, **kwargs):
return xbmc.getLanguage(*args, **kwargs)
def process(provider, generator, filtering, has_special, verify_name=True, verify_size=True, skip_auth=False, start_time=None, timeout=None):
""" Method for processing provider results using its generator and Filtering class instance
Args:
provider (str): Provider ID
generator (function): Generator method, can be either ``extract_torrents`` or ``extract_from_api``
filtering (Filtering): Filtering class instance
has_special (bool): Whether title contains special chars
verify_name (bool): Whether to double-check the results' names match the query or not
verify_size (bool): Whether to check the results' file sizes
"""
log.debug("[%s] execute_process for %s with %s" % (provider, provider, repr(generator)))
definition = definitions[provider]
definition = get_alias(definition, get_setting("%s_alias" % provider))
client = Client(info=filtering.info, request_charset=definition['charset'], response_charset=definition['response_charset'])
token = None
logged_in = False
token_auth = False
if get_setting('kodi_language', bool):
kodi_language = xbmc.getLanguage(xbmc.ISO_639_1)
if kodi_language:
filtering.kodi_language = kodi_language
language_exceptions = get_setting('language_exceptions')
if language_exceptions.strip().lower():
filtering.language_exceptions = re.split(r',\s?', language_exceptions)
log.debug("[%s] Queries: %s" % (provider, filtering.queries))
log.debug("[%s] Extras: %s" % (provider, filtering.extras))
for query, extra in zip(filtering.queries, filtering.extras):
log.debug("[%s] Before keywords - Query: %s - Extra: %s" % (provider, repr(query), repr(extra)))
if has_special:
# Removing quotes, surrounding {title*} keywords, when title contains special chars
query = re.sub("[\"']({title.*?})[\"']", '\\1', query)
query = filtering.process_keywords(provider, query)
extra = filtering.process_keywords(provider, extra)
if not query:
continue
elif extra == '-' and filtering.results:
continue
elif start_time and timeout and time.time() - start_time + 3 >= timeout:
# Stop doing requests if there is 3 seconds left for the overall task
continue
try:
if 'charset' in definition and definition['charset'] and 'utf' not in definition['charset'].lower():
query = quote(query.encode(definition['charset']))
extra = quote(extra.encode(definition['charset']))
else:
query = quote(py2_encode(query))
extra = quote(py2_encode(extra))
except Exception as e:
log.debug("[%s] Could not quote the query (%s): %s" % (provider, query, e))
pass
log.debug("[%s] After keywords - Query: %s - Extra: %s" % (provider, repr(query), repr(extra)))
if not query:
return filtering.results
url_search = filtering.url.replace('QUERY', query)
if extra and extra != '-':
url_search = url_search.replace('EXTRA', extra)
else:
url_search = url_search.replace('EXTRA', '')
url_search = url_search.replace(' ', definition['separator'])
if definition['separator'] != '%20':
url_search = url_search.replace('%20', definition['separator'])
# MagnetDL fix...
url_search = url_search.replace('FIRSTLETTER', query[:1])
# Creating the payload for POST method
if 'post_data' in definition and not filtering.post_data:
filtering.post_data = eval(definition['post_data'])
payload = dict()
for key, value in iteritems(filtering.post_data):
if 'QUERY' in value:
payload[key] = filtering.post_data[key].replace('QUERY', query)
else:
payload[key] = filtering.post_data[key]
payload[key] = urllib.unquote(payload[key])
# Creating the payload for GET method
headers = None
data = None
if filtering.get_data:
data = dict()
for key, value in iteritems(filtering.get_data):
if 'QUERY' in value:
data[key] = filtering.get_data[key].replace('QUERY', query)
else:
data[key] = filtering.get_data[key]
log.debug("- %s query: %s" % (provider, repr(query)))
log.debug("-- %s url_search before token: %s" % (provider, repr(url_search)))
log.debug("--- %s using POST payload: %s" % (provider, repr(payload)))
log.debug("----%s filtering with post_data: %s" % (provider, repr(filtering.post_data)))
# Set search's "title" in filtering to double-check results' names
if 'filter_title' in definition and definition['filter_title']:
filtering.filter_title = True
filtering.title = query
if 'initial_url' in definition and definition['initial_url']:
url = definition['initial_url']
if not url.startswith('http'):
url = definition['root_url'] + url
client.open(url)
if token:
log.info('[%s] Reusing existing token' % provider)
url_search = url_search.replace('TOKEN', token)
elif 'token' in definition:
token_url = definition['base_url'] + definition['token']
log.debug("[%s] Getting token for %s at %s" % (provider, provider, repr(token_url)))
client.open(py2_encode(token_url))
try:
token_data = json.loads(client.content)
except:
log.error('%s: Failed to get token for %s' % (provider, repr(url_search)))
return filtering.results
log.debug("[%s] Token response for %s: %s" % (provider, provider, repr(token_data)))
if 'token' in token_data:
token = token_data['token']
log.debug("[%s] Got token for %s: %s" % (provider, provider, repr(token)))
url_search = url_search.replace('TOKEN', token)
else:
log.warning('%s: Unable to get token for %s' % (provider, repr(url_search)))
if logged_in:
log.info("[%s] Reusing previous login" % provider)
elif token_auth:
log.info("[%s] Reusing previous token authorization" % provider)
elif 'private' in definition and definition['private']:
username = get_setting('%s_username' % provider, unicode)
password = get_setting('%s_password' % provider, unicode)
passkey = get_setting('%s_passkey' % provider, unicode)
if not username and not password and not passkey:
for addon_name in ('script.magnetic.%s' % provider, 'script.magnetic.%s-mc' % provider):
for setting in ('username', 'password'):
try:
value = xbmcaddon.Addon(addon_name).getSetting(setting)
set_setting('%s_%s' % (provider, setting), value)
if setting == 'username':
username = value
if setting == 'password':
password = value
except:
pass
if username:
client.username = username
url_search = url_search.replace('USERNAME', username)
if passkey:
logged_in = True
client.passkey = passkey
url_search = url_search.replace('PASSKEY', passkey)
elif 'login_object' in definition and definition['login_object']:
login_object = None
login_headers = None
logged_in = skip_auth
try:
login_object = definition['login_object'].replace('USERNAME', 'u"%s"' % username).replace('PASSWORD', 'u"%s"' % password)
except Exception as e:
log.error("Could not make login object for %s: %s" % (provider, e))
try:
if 'login_headers' in definition and definition['login_headers']:
login_headers = eval(definition['login_headers'])
except Exception as e:
log.error("Could not make login headers for %s: %s" % (provider, e))
# TODO generic flags in definitions for those...
if 'csrf_token' in definition and definition['csrf_token']:
client.open(definition['root_url'] + definition['login_path'])
if client.content:
csrf_token = re.search(r'name=\"_?csrf_token\" value=\"(.*?)\"', client.content)
if csrf_token:
login_object = login_object.replace('CSRF_TOKEN', '"%s"' % csrf_token.group(1))
else:
logged_in = True
if 'token_auth' in definition:
# log.debug("[%s] logging in with: %s" % (provider, login_object))
if client.open(definition['root_url'] + definition['token_auth'], post_data=eval(login_object)):
try:
token_data = json.loads(client.content)
except:
log.error('%s: Failed to get token from %s' % (provider, definition['token_auth']))
return filtering.results
log.debug("[%s] Token response for %s: %s" % (provider, provider, repr(token_data)))
if 'token' in token_data:
client.token = token_data['token']
log.debug("[%s] Auth token for %s: %s" % (provider, provider, repr(client.token)))
else:
log.error('[%s] Unable to get auth token for %s' % (provider, repr(url_search)))
return filtering.results
log.info('[%s] Token auth successful' % provider)
token_auth = True
else:
log.error("[%s] Token auth failed with response: %s" % (provider, repr(client.content)))
return filtering.results
elif not logged_in and client.login(definition['root_url'], definition['login_path'],
eval(login_object), login_headers, definition['login_failed']):
log.info('[%s] Login successful' % provider)
logged_in = True
elif not logged_in:
log.error("[%s] Login failed: %s", provider, client.status)
log.debug("[%s] Failed login content: %s", provider, repr(client.content))
return filtering.results
if logged_in:
if provider == 'hd-torrents':
client.open(definition['root_url'] + '/torrents.php')
csrf_token = re.search(r'name="csrfToken" value="(.*?)"', client.content)
url_search = url_search.replace("CSRF_TOKEN", csrf_token.group(1))
client.save_cookies()
log.info("[%s] > %s search URL: %s" % (provider, definition['name'].rjust(longest), url_search))
if 'headers' in definition and definition['headers']:
headers = eval(definition['headers'])
log.info("[%s] > %s headers: %s" % (provider, definition['name'].rjust(longest), headers))
client.open(py2_encode(url_search), post_data=payload, get_data=data, headers=headers)
filtering.results.extend(
generate_payload(provider,
generator(provider, client),
filtering,
verify_name,
verify_size))
return filtering.results
def __init__(self, url, handle):
self.url = url
self.handle = handle
self.limit = get_setting("items_per_page", int)
self.language = xbmc.getLanguage(xbmc.ISO_639_1)
def search(payload, method="general"):
""" Main search entrypoint
Args:
payload (dict): Search payload from Elementum.
method (str): Type of search, can be ``general``, ``movie``, ``show``, ``season`` or ``anime``
Returns:
list: All filtered results in the format Elementum expects
"""
log.debug("Searching with payload (%s): %s" % (method, repr(payload)))
if 'anime' in payload and payload['anime']:
method = 'anime'
if method == 'general':
if 'query' in payload:
payload['title'] = payload['query']
payload['titles'] = {
'source': payload['query']
}
else:
payload = {
'title': payload,
'titles': {
'source': payload
},
}
payload['titles'] = dict((k.lower(), v) for k, v in iteritems(payload['titles']))
# If titles[] exists in payload and there are special chars in titles[source]
# then we set a flag to possibly modify the search query
payload['has_special'] = 'titles' in payload and \
bool(payload['titles']) and \
'source' in payload['titles'] and \
any(c in payload['titles']['source'] for c in special_chars)
if payload['has_special']:
log.debug("Query title contains special chars, so removing any quotes in the search query")
if 'proxy_url' not in payload:
payload['proxy_url'] = ''
if 'internal_proxy_url' not in payload:
payload['internal_proxy_url'] = ''
if 'elementum_url' not in payload:
payload['elementum_url'] = ''
if 'silent' not in payload:
payload['silent'] = False
if 'skip_auth' not in payload:
payload['skip_auth'] = False
global request_time
global provider_cache
global provider_names
global provider_results
global available_providers
provider_cache = {}
provider_names = []
provider_results = []
available_providers = 0
request_time = time.time()
providers = get_enabled_providers(method)
if len(providers) == 0:
if not payload['silent']:
notify(translation(32060), image=get_icon_path())
log.error("No providers enabled")
return []
log.info("Burstin' with %s" % ", ".join([definitions[provider]['name'] for provider in providers]))
if use_kodi_language:
kodi_language = xbmc.getLanguage(xbmc.ISO_639_1)
if not kodi_language:
log.warning("Kodi returned empty language code...")
elif 'titles' not in payload or not payload['titles']:
log.info("No translations available...")
elif payload['titles'] and kodi_language not in payload['titles']:
log.info("No '%s' translation available..." % kodi_language)
p_dialog = xbmcgui.DialogProgressBG()
if not payload['silent']:
p_dialog.create('Elementum [COLOR FFFF6B00]Burst[/COLOR]', translation(32061))
providers_time = time.time()
for provider in providers:
available_providers += 1
provider_names.append(definitions[provider]['name'])
task = Thread(target=run_provider, args=(provider, payload, method, providers_time, timeout))
task.start()
total = float(available_providers)
# Exit if all providers have returned results or timeout reached, check every 100ms
while time.time() - providers_time < timeout and available_providers > 0:
timer = time.time() - providers_time
log.debug("Timer: %ds / %ds" % (timer, timeout))
if timer > timeout:
break
message = translation(32062) % available_providers if available_providers > 1 else translation(32063)
if not payload['silent']:
p_dialog.update(int((total - available_providers) / total * 100), message=message)
time.sleep(0.25)
if not payload['silent']:
p_dialog.close()
del p_dialog
if available_providers > 0:
message = ', '.join(provider_names)
message = message + translation(32064)
log.warning(message)
if not payload['silent']:
notify(message, ADDON_ICON)
log.debug("all provider_results of %d: %s" % (len(provider_results), repr(provider_results)))
filtered_results = apply_filters(provider_results)
log.debug("all filtered_results of %d: %s" % (len(filtered_results), repr(filtered_results)))
log.info("Providers returned %d results in %s seconds" % (len(filtered_results), round(time.time() - request_time, 2)))
return filtered_results
# Plugin Info
ADDON_ID = 'screensaver.bing'
REAL_SETTINGS = xbmcaddon.Addon(id=ADDON_ID)
ADDON_NAME = REAL_SETTINGS.getAddonInfo('name')
SETTINGS_LOC = REAL_SETTINGS.getAddonInfo('profile')
ADDON_PATH = REAL_SETTINGS.getAddonInfo('path')
ADDON_VERSION = REAL_SETTINGS.getAddonInfo('version')
ICON = REAL_SETTINGS.getAddonInfo('icon')
FANART = REAL_SETTINGS.getAddonInfo('fanart')
LANGUAGE = REAL_SETTINGS.getLocalizedString
KODI_MONITOR = xbmc.Monitor()
BASE_URL = 'https://www.bing.com'
POTD_JSON = 'https://www.bing.com/hpimagearchive.aspx?format=js&idx=%i&n=8&mkt=%s' % (
random.randint(0, 7), xbmc.getLanguage(xbmc.ISO_639_1, True))
TIMER = [30, 60, 120, 240][int(REAL_SETTINGS.getSetting("RotateTime"))]
RANDOM = REAL_SETTINGS.getSetting("Randomize") == 'true'
IDX_LST = [1, 2, 3, 4, 5, 6, 7, 0]
CYC_INTER = cycle(IDX_LST).__next__
class GUI(xbmcgui.WindowXMLDialog):
def __init__(self, *args, **kwargs):
self.cache = SimpleCache()
self.isExiting = False
def log(self, msg, level=xbmc.LOGDEBUG):
xbmc.log('%s-%s-%s' % (ADDON_ID, ADDON_VERSION, msg), level)
def notificationDialog(self,
def gui_language(self):
language = xbmc.getLanguage().split(' (')[0]
return xbmc.convertLanguage(language, xbmc.ISO_639_1)
