def resolve_url(self, raw_url):
resolved_url = ''
host = self.get_domain_from_url(raw_url)
if host not in self.get_domains(): return ''
from commoncore.dispatcher import WeightedDispatcher
dispatcher = WeightedDispatcher()
@dispatcher.register(kodi.get_setting('premiumize_priority', ADDON_ID),
[raw_url])
def pm_resolver(raw_url):
if host not in self.premiumize_hosts: return ''
try:
response = premiumize.get_download(raw_url)
return response['result']['location']
except:
return ''
@dispatcher.register(kodi.get_setting('realdebrid_priority', ADDON_ID),
[raw_url])
def rd_resolver(raw_url):
if host not in self.realdebrid_hosts: return ''
try:
return realdebrid.resolve_url(raw_url)
except:
return ''
kodi.open_busy_dialog()
try:
resolved_url = dispatcher.run()
except:
kodi.close_busy_dialog()
kodi.close_busy_dialog()
return resolved_url
class PremiumizeScraper(PremiumScraper):
valid = kodi.get_setting('premiumize_enable',
ADDON_ID) == 'true' and kodi.get_setting(
'premiumize_username', ADDON_ID) != ''
'''def __init__(self):
self._make_media_object = self.make_media_object
def make_media_object(obj):
media = self._make_media_object(obj)
media['premium'] = 'PM'
return media
self.make_media_object = make_media_object'''
def verify_result(self, result):
if result[0]['host'] not in self.domains: return
media = self.make_media_object(result[0])
self.verified_results.append(media)
def get_domains(self):
self.domains = premiumize.get_hosts()
def resolve_url(self, raw_url):
response = premiumize.get_download(raw_url)
try:
return response['result']['location']
except:
return ''
def resolve_url(self, raw_url):
host = self.get_domain_from_url(raw_url)
if host not in self.domains: return ''
resolvers = []
def pm_resolver(raw_url):
if host not in self.premiumize_hosts: return ''
try:
response = premiumize.get_download(raw_url)
return response['result']['location']
except:
return ''
resolvers.append([kodi.get_setting('premiumize_priority', ADDON_ID), pm_resolver])
def rd_resolver(raw_url):
if host not in self.realdebrid_hosts: return ''
try:
return realdebrid.resolve_url(raw_url)
except:
return ''
resolvers.append([kodi.get_setting('realdebrid_priority', ADDON_ID), rd_resolver])
resolvers.sort(key=lambda x: x[0], reverse=True)
for r in resolvers:
r = r[1]
resolved_url = r(raw_url)
if resolved_url: return resolved_url
return ''
def check_hashes(self, hashes):
results = {'realdebrid': {}, "premiumize": {}}
if kodi.get_setting('realdebrid_enable', ADDON_ID) == 'true':
results['realdebrid'] = realdebrid.check_hashes(hashes)
if kodi.get_setting('premiumize_enable', ADDON_ID) == 'true':
results['premiumize'] = premiumize.check_hashes(hashes)
return results
def get_user_agent(self):
user_agent = kodi.get_setting('user_agent')
try: agent_refresh_time = int(kodi.get_setting('agent_refresh_time'))
except: agent_refresh_time = 0
if not user_agent or agent_refresh_time < (time.time() - (7 * 24 * 60 * 60)):
user_agent = self.generate_user_agent()
kodi.set_setting('user_agent', user_agent)
kodi.set_setting('agent_refresh_time', str(int(time.time())))
return user_agent
def __init__(self):
self.dsn = {
"database": kodi.get_setting('database_mysql_name'),
"host": kodi.get_setting('database_mysql_host'),
"port": int(kodi.get_setting('database_mysql_port')),
"user": kodi.get_setting('database_mysql_user'),
"password": kodi.get_setting('database_mysql_pass'),
"buffered": True
}
self.connect()
class PremiumScraper(BaseScraper):
valid = kodi.get_setting('premiumize_enable', ADDON_ID) == 'true' and kodi.get_setting('premiumize_username', ADDON_ID) != '' or kodi.get_setting('realdebrid_enable', ADDON_ID) == 'true' and kodi.get_setting('realdebrid_token', ADDON_ID) != ''
def get_domains(self):
self.realdebrid_hosts = realdebrid.get_hosts()
self.premiumize_hosts = premiumize.get_hosts()
self.domains = list(set(self.realdebrid_hosts + self.premiumize_hosts))
return self.domains
def verify_result(self, result):
if result[0]['host'] not in self.domains: return
media = self.make_media_object(result[0])
self.verified_results.append(media)
def verify_results(self, processor, results):
self.get_domains()
for result in results:
if isinstance(result, list):
for r in result:
self.verify_result(processor(r))
else:
self.verify_result(processor(result))
return (self.name, self.verified_results)
def resolve_url(self, raw_url):
host = self.get_domain_from_url(raw_url)
if host not in self.domains: return ''
resolvers = []
def pm_resolver(raw_url):
if host not in self.premiumize_hosts: return ''
try:
response = premiumize.get_download(raw_url)
return response['result']['location']
except:
return ''
resolvers.append([kodi.get_setting('premiumize_priority', ADDON_ID), pm_resolver])
def rd_resolver(raw_url):
if host not in self.realdebrid_hosts: return ''
try:
return realdebrid.resolve_url(raw_url)
except:
return ''
resolvers.append([kodi.get_setting('realdebrid_priority', ADDON_ID), rd_resolver])
resolvers.sort(key=lambda x: x[0], reverse=True)
for r in resolvers:
r = r[1]
resolved_url = r(raw_url)
if resolved_url: return resolved_url
return ''
def get_domains(self):
if kodi.get_setting('realdebrid_enable', ADDON_ID) == 'true':
self.realdebrid_hosts = realdebrid.get_hosts()
else:
self.realdebrid_hosts = []
if kodi.get_setting('premiumize_enable', ADDON_ID) == 'true':
self.premiumize_hosts = premiumize.get_hosts()
else:
self.premiumize_hosts = []
self.domains = list(set(self.realdebrid_hosts + self.premiumize_hosts))
return self.domains
class RealDebridScraper(PremiumScraper):
valid = kodi.get_setting('realdebrid_enable', ADDON_ID) == 'true' and kodi.get_setting('realdebrid_token', ADDON_ID) != ''
def get_domains(self):
self.domains = realdebrid.get_hosts()
def __init__(self):
self._make_media_object = self.make_media_object
def make_media_object(obj):
media = self._make_media_object(obj)
media['premium'] = 'RD'
return media
self.make_media_object = make_media_object
def resolve_url(self, raw_url):
return realdebrid.resolve_url(raw_url)
def verify_hash(self, hash):
if kodi.get_setting('realdebrid_enable', ADDON_ID) == 'true':
try:
if self.verified_hashes['realdebrid'][hash]['rd'] != []:
return True
except:
pass
if kodi.get_setting('premiumize_enable', ADDON_ID) == 'true':
try:
if self.verified_hashes['premiumize']['hashes'][hash][
'status'] == 'finished':
return True
except:
pass
return False
def __init__(self, *args, **kwargs):
self.ftp_root = kodi.vfs.translate_path(
kodi.get_setting('root_directory'))
self.ftp_log = kodi.vfs.join(kodi.get_profile(), "pyftpd.log")
self.cert_file = vfs.join(kodi.get_profile(), "pyftpd.pem")
if not vfs.exists(self.cert_file):
vfs.cp(vfs.join(kodi.get_path(), "pyftpd.pem"), self.cert_file)
def get_season_art(self, tvdb_id):
result = {}
def sort_art(record):
return record['ratingsInfo']['average']
try:
uri = "/series/%s/images/query" % tvdb_id
response = self.request(uri,
query={"keyType": "season"},
auth=True,
cache_limit=EXPIRE_TIMES.WEEK)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
data = sorted(response['data'],
reverse=True,
key=lambda k: sort_art(k))
for d in data:
s = int(d["subKey"])
if s == 0: continue
img = "http://thetvdb.com/banners/" + d["fileName"]
result[s] = img
except:
pass
return result
def refresh_token():
url = 'https://api.real-debrid.com/oauth/v2/token'
data = {'client_id': kodi.get_setting('realdebrid_client_id', addon_id='script.module.scrapecore'), 'client_secret': kodi.get_setting('realdebrid_client_secret', addon_id='script.module.scrapecore'), 'code': kodi.get_setting('realdebrid_refresh_token', addon_id='script.module.scrapecore'), 'grant_type': 'http://oauth.net/grant_type/device/1.0'}
response = session.post(url, data=data)
response.json()
if 'access_token' in response:
kodi.set_setting('realdebrid_token', response['access_token'], addon_id='script.module.scrapecore')
return response
def show_about():
if kodi.get_setting('disable_about') == 'true': return
interval = int(kodi.get_setting('last_about'))
if interval == 0:
interval = 5
try:
import xbmc
KODI_LANGUAGE = xbmc.getLanguage()
except:
KODI_LANGUAGE = 'English'
path = kodi.vfs.join(kodi.get_path(), 'resources/language/%s/github_help.txt', KODI_LANGUAGE)
if not kodi.vfs.exists(path):
path = kodi.vfs.join(kodi.get_path(), 'resources/language/English/github_help.txt')
text = kodi.vfs.read_file(path)
kodi.dialog_textbox('GitHub Browser Instructions', text)
else:
interval -= 1
kodi.set_setting('last_about', interval)
def show_about():
if kodi.get_setting('disable_about') == 'true': return
interval = int(kodi.get_setting('last_about'))
if interval == 0:
interval = 5
try:
import xbmc
KODI_LANGUAGE = xbmc.getLanguage()
except:
KODI_LANGUAGE = 'English'
path = kodi.vfs.join(kodi.get_path(), 'resources/language/%s/github_help.txt', KODI_LANGUAGE)
if not kodi.vfs.exists(path):
path = kodi.vfs.join(kodi.get_path(), 'resources/language/English/github_help.txt')
text = kodi.vfs.read_file(path)
kodi.dialog_textbox('GitHub Browser Instructions', text)
else:
interval -= 1
kodi.set_setting('last_about', interval)
def settings_menu():
menu = kodi.ContextMenu()
menu.add(
'Set Default View', {
"mode": "set_default_view",
"api": {
"name": "kodi",
"method": "set_default_view",
"args": ("list", )
}
})
kodi.add_menu_item(
{'mode': 'realdebrid_menu'}, {'title': "RealDebrid"},
icon='realdebrid.png',
visible=kodi.get_setting('realdebrid_enable',
'script.module.scrapecore') == 'true')
kodi.add_menu_item(
{'mode': 'premiumize_menu'}, {'title': "Premiumize Cloud"},
icon='cloud.png',
visible=kodi.get_setting('premiumize_enable',
'script.module.scrapecore') == 'true')
kodi.add_menu_item(
{
'mode': 'scrapecore_settings',
"api": {
"name": "kodi",
"method": "open_settings",
"args": ("script.module.scrapecore", )
}
}, {'title': "ScrapeCore Settings"},
icon='settings.png')
kodi.add_menu_item(
{
'mode': 'open_settings',
'addon_id': 'service.fanart.proxy'
}, {'title': "Fanart Proxy Settings"},
icon='settings.png',
visible=kodi.has_addon('service.fanart.proxy'))
kodi.add_menu_item({'mode': 'commoncore_settings'},
{'title': "CommonCore Settings"},
icon='settings.png')
kodi.add_menu_item({'mode': 'addon_settings'}, {'title': "Addon Settings"},
icon='settings.png')
kodi.eod(DEFAULT_VIEWS.LIST)
def scraper_list():
for s in scrapecore.get_scrapers():
if kodi.get_setting(s['service'] + '_enable') == 'true':
title = format_color(s['name'], 'green')
else:
title = format_color(s['name'], 'maroon')
kodi.add_menu_item({
'mode': 'toggle_scraper',
"service": s['service']
}, {'title': title},
icon='')
kodi.eod()
def get_person_art(self, tmdb_id):
try:
uri = "/person/%s" % tmdb_id
response = self.request(uri)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
if 'profile_path' in response and response[
'profile_path'] is not None:
return "http://image.tmdb.org/t/p/w500%s" % response[
'profile_path']
except:
return False
def get_episode_art(self, tmdb_id, tvdb_id, imdb_id, season, episode):
try:
uri = "/tv/%s/season/%s/episode/%s/images" % (tmdb_id, season,
episode)
response = self.request(uri, cache_limit=EXPIRE_TIMES.DAY)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
if response and 'stills' in response and response['stills']:
return "http://image.tmdb.org/t/p/w500%s" % response['stills'][
0]['file_path']
except:
return False
def refresh_token():
url = 'https://api.real-debrid.com/oauth/v2/token'
data = {
'client_id':
kodi.get_setting('realdebrid_client_id',
addon_id='script.module.scrapecore'),
'client_secret':
kodi.get_setting('realdebrid_client_secret',
addon_id='script.module.scrapecore'),
'code':
kodi.get_setting('realdebrid_refresh_token',
addon_id='script.module.scrapecore'),
'grant_type':
'http://oauth.net/grant_type/device/1.0'
}
response = session.post(url, data=data)
response.json()
if 'access_token' in response:
kodi.set_setting('realdebrid_token',
response['access_token'],
addon_id='script.module.scrapecore')
return response
def get_episode_art(self, tmdb_id, tvdb_id, imdb_id, season, episode):
try:
uri = '/episodes/%s' % tvdb_id
response = self.request(uri,
auth=True,
cache_limit=EXPIRE_TIMES.DAY)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
if response and 'data' in response and response['data']['filename']:
return 'http://thetvdb.com/banners/_cache/' + response['data'][
'filename']
except:
return False
def __init__(self, supported_scrapers, load_list=None, ignore_list=[]):
# Verify each scraper is enabled removing ignored
# We generate the list of active scrapers
# Each scraper is given the abort event. This can be respected in the individual scraper.
# However if ignored, the thread will be allowed to continue and its results ignored
for s in supported_scrapers:
s.abort_event = self.abort_event
if s.service in ignore_list: continue
if type(load_list) is list and s.service not in load_list: continue
if kodi.get_setting(s.service + '_enable',
addon_id=ADDON_ID) == 'true' and s.valid:
self.active_scrapers[s.service] = s
self.count = len(self.active_scrapers)
def premiumize_resolver(raw_url):
resolved_url = ''
if kodi.get_setting('premiumize_enable', ADDON_ID) != 'true':
return resolved_url
attempt = 0
attempts = 5
try:
response = premiumize.create_transfer(raw_url)
id = response['id']
except:
premiumize.clear_transfers()
response = premiumize.create_transfer(raw_url)
id = response['id']
try:
while attempt < attempts:
folder_id = False
file_id = False
target_folder_id = False
kodi.log("Resolve Attempt %s" % attempt)
temp = premiumize.list_transfers()
for t in temp['transfers']:
if t['id'] == id and t['status'] == 'finished':
if 'target_folder_id' in t:
target_folder_id = t['target_folder_id']
if 'folder_id' in t: folder_id = t['folder_id']
if 'file_id' in t: file_id = t['file_id']
break
if file_id:
response = premiumize.item_details(file_id)
resolved_url = response['stream_link']
kodi.set_property('Playback.Resolver', 'premiumize')
kodi.set_property('Playback.ID', file_id)
return resolved_url
if folder_id:
response = premiumize.list_folder(folder_id)
resolved_url = premiumize.get_folder_stream(response)
kodi.set_property('Playback.Resolver', 'premiumize')
kodi.set_property('Playback.ID', folder_id)
return resolved_url
if target_folder_id:
response = premiumize.list_folder(target_folder_id)
resolved_url = premiumize.get_folder_stream(response)
kodi.set_property('Playback.Resolver', 'premiumize')
kodi.set_property('Playback.ID', target_folder_id)
return resolved_url
attempt += 1
kodi.sleep(150)
except:
pass
return resolved_url
def start(self):
class Monitor(xbmc.Monitor):
def onSettingsChanged(self):
pass
monitor = Monitor()
kodi.log("Service Starting...")
self.clear_art()
if kodi.get_setting('enable_fanart_proxy') == 'true':
CONTROL_PORT = int(kodi.get_setting('control_port'))
if kodi.get_setting('network_bind') == 'Localhost':
address = "127.0.0.1"
else:
address = "0.0.0.0"
CONTROL_PROTO = kodi.get_setting('control_protocol')
kodi.log("Launching Fanart WebInterface on: %s://%s:%s" %
(CONTROL_PROTO, address, CONTROL_PORT))
kodi.log("Verify at: %s://%s:%s/api/up" %
(CONTROL_PROTO, address, CONTROL_PORT))
try:
if CONTROL_PROTO == 'https':
from commoncore.webservice import HttpsServer
certfile = kodi.vfs.join(kodi.get_path(),
"resources/server.pem")
self.httpd = HttpsServer(address, CONTROL_PORT, certfile,
RequestHandler)
self.webserver = Thread(target=self.httpd.serve_forever)
else:
from commoncore.webservice import HttpServer
self.httpd = HttpServer(address, CONTROL_PORT,
RequestHandler)
self.webserver = Thread(target=self.httpd.serve_forever)
except Exception, e:
kodi.log(e)
kodi.raise_error("Service Error: ", str(e))
sys.exit()
self.webserver.start()
def get_movie_art(self, tmdb_id, imdb_id):
result = {"fanart": "", "poster": ""}
try:
response = self.request('/api',
data={
"id": imdb_id,
"key": IMDB_KEY
})
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
result['poster'] = response['poster'].split('._')[0]
except:
pass
return result
def get_show_art(self, tmdb_id, tvdb_id, imdb_id):
result = {"fanart": "", "poster": ""}
try:
response = self.request('/',
query={
"i": imdb_id,
"apikey": OIMDB_KEY
})
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
result['poster'] = response['Poster'].split('._')[0]
except:
pass
return result
def start(self):
class Monitor(xbmc.Monitor):
def onSettingsChanged(self):
pass
monitor = Monitor()
kodi.log("Service Starting...")
authorizer = DummyAuthorizer()
authorizer.add_user(kodi.get_setting('ftp_user'),
kodi.get_setting('ftp_pass'),
self.ftp_root,
perm='elradfmwMT')
if kodi.get_setting('use_ssl') == 'true':
from pyftpdlib.handlers import TLS_FTPHandler as handler
handler.certfile = self.cert_file
else:
from pyftpdlib.handlers import FTPHandler as handler
handler.banner = "PyFTPd ready."
handler.authorizer = authorizer
address = ('', kodi.get_setting('server_port'))
import logging
logging.basicConfig(filename=self.ftp_log, level=logging.INFO)
self.ftpd = ThreadedFTPServer(address, handler)
self.ftpd.max_cons = 256
self.ftpd.max_cons_per_ip = 5
self.server = Thread(target=self.ftpd.serve_forever)
self.server.start()
if is_depricated:
while not xbmc.abortRequested:
xbmc.sleep(1000)
else:
while not monitor.abortRequested():
xbmc.sleep(1000)
self.shutdown()
def get_show_art(self, tmdb_id, tvdb_id, imdb_id):
result = {"fanart": "", "poster": ""}
def sort_art(record):
return record['ratingsInfo']['average']
uri = "/series/%s/images/query" % tvdb_id
try:
response = self.request(uri,
query={"keyType": "fanart"},
auth=True,
cache_limit=EXPIRE_TIMES.WEEK)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
data = sorted(response['data'],
reverse=True,
key=lambda k: sort_art(k))
result[
"fanart"] = "http://thetvdb.com/banners/" + data[0]['fileName']
except:
pass
try:
response = self.request(uri,
query={"keyType": "poster"},
auth=True,
cache_limit=EXPIRE_TIMES.WEEK)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
data = sorted(response['data'],
reverse=True,
key=lambda k: sort_art(k))
result[
"poster"] = "http://thetvdb.com/banners/" + data[0]['fileName']
except:
pass
return result
def build_url(self, uri, query, append_base):
if append_base:
url = self.base_url + uri
token = kodi.get_setting('access_token')
if token:
if query is None:
query = {"access_token": token}
else:
query["access_token"] = token
if query is not None:
query = urllib.urlencode(query)
for r in [('%3A', ":"), ("%2B", "+")]:
f,t = r
query = query.replace(f,t)
url += '?' + query
return url
def build_url(self, uri, query, append_base):
if append_base:
url = self.base_url + uri
token = kodi.get_setting('access_token')
if token:
if query is None:
query = {"access_token": token}
else:
query["access_token"] = token
if query is not None:
query = urllib.urlencode(query)
for r in [('%3A', ":"), ("%2B", "+")]:
f, t = r
query = query.replace(f, t)
url += '?' + query
return url
def do_Response(self,
content={
'status': 200,
'message': 'success'
},
content_type='application/json',
response_code=200):
self.generate_response_headers(content_type=content_type)
self.send_all_headers(response_code)
if content_type == 'application/json':
content['host'] = HOST_ADDRESS
content['debug'] = kodi.get_setting(
'enable_fanart_debug') == 'true'
content = json.dumps(content)
self.wfile.write(content)
self.wfile.flush()
self.wfile.close()
def get_season_art(self, tvdb_id):
result = {}
uri = '/tv/%s' % tvdb_id
try:
response = self.request(uri, cache_limit=EXPIRE_TIMES.WEEK)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
except:
return result
try:
for poster in response['seasonposter']:
if poster['lang'] != 'en' or int(poster['season']) in result:
continue
result[int(poster['season'])] = poster['url']
except:
pass
return result
def get_episode_art(self, tmdb_id, tvdb_id, imdb_id, season, episode):
try:
tvmaze_id = self.lookup_id(imdb_id)
if not tvmaze_id: return False
uri = "/shows/%s/episodes" % tvmaze_id
response = self.request(uri,
query={"specials": 0},
cache_limit=EXPIRE_TIMES.DAY)
if kodi.get_setting('enable_fanart_debug') == "true":
kodi.log(response)
season = int(season)
episode = int(season)
for e in response:
if e['season'] == season and e['number'] == episode:
if e['image'] is not None:
return e['image']['original']
except:
return False
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*'''
import re
import json
import requests
from commoncore import kodi
vfs = kodi.vfs
try:
myth_host = kodi.get_setting('host', 'pvr.mythtv')
myth_port = kodi.get_setting('wsport', 'pvr.mythtv')
except:
myth_host = ''
myth_port = ''
_base_url = 'http://%s:%s' % (myth_host, myth_port)
session = requests.Session()
def process_response(response, return_type='xml'):
if return_type == 'json':
return json.loads(response)
elif return_type == 'xml':
import xml.etree.ElementTree as ET
if type(response) == unicode:
response = response.encode("utf-8", errors="ignore")
def authorize(self):
self.headers = {"Authorization": "Bearer %s" % kodi.get_setting('realdebrid_token', addon_id='script.module.scrapecore')}
def build_dependency_list(self, addon_id, url, full_name, master):
#if test in ['xbmc.python', 'xbmc.gui'] or kodi.get_condition_visiblity('System.HasAddon(%s)' % addon_id) == 1: return True
if addon_id in self.installed_list:
kodi.log('Dependency is already installed: %s' % addon_id)
return True
user, repo = full_name.split("/")
kodi.log('Finding dependencies for: %s' % addon_id)
if master:
self.sources[addon_id] = {"type": SOURCES.REPO, "url": url, "user": user, "repo": repo, "version": ""}
xml_str = github.find_xml(full_name)
self.sources[addon_id]['version'] = github.get_version_by_xml(BeautifulSoup(xml_str))
else:
version = downloader.download(url, addon_id, self._destination, True, self.quiet)
src_file = kodi.vfs.join("special://home/addons", addon_id)
kodi.vfs.join(src_file, "addon.xml")
xml = kodi.vfs.read_file(kodi.vfs.join(src_file, "addon.xml"), soup=True)
self.save_source(addon_id, {"type": SOURCES.ZIP, "url": url, "user": user, "repo": repo, "version": version})
for dep in xml.findAll('import'):
test = dep['addon']
try:
if dep['optional'].lower() == 'true':
if kodi.get_setting('install_optional') == 'false':
continue
elif kodi.get_setting('prompt_optional') == "true":
c = kodi.dialog_confirm("Install Optional Dependency", dep['name'], dep['addon'])
if not c: continue
except:
pass
if test in ['xbmc.python', 'xbmc.gui'] or kodi.get_condition_visiblity('System.HasAddon(%s)' % test) == 1 or test in self.installed_list:
kodi.log('Dependency is already installed: %s' % test)
continue
self.required_addons += [test]
if test not in self.available_addons:
self.unmet_addons += [test]
else:
self.sources[test] = {"type": SOURCES.DEFAULT, "url": self.source_table[test]}
kodi.log("%s dependency met in %s" % (test, self.source_table[test]))
def user_resolver(user, unmet):
dep_url, dep_filename, dep_full_name, version = github.find_zip(user, unmet)
if dep_url:
kodi.log("%s found in %s repo" % (unmet, user))
self.met_addons.append(unmet)
user, repo = dep_full_name.split("/")
self.sources[unmet] = {"type": SOURCES.ZIP, "url": dep_url, "user": user, "repo": repo, "version": ""}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
return True
return False
def github_resolver(unmet):
results = github.web_search(unmet)
c = kodi.dialog_select("GitHub Search Results for %s" % unmet, [r['full_name'] for r in results['items']])
if c is not False:
dep = results['items'][c]
dep_url = url = "https://github.com/%s/archive/master.zip" % (dep['full_name'])
self.met_addons.append(unmet)
dep_filename = "%s.zip" % unmet
self.sources[unmet] = {"type": SOURCES.REPO, "url": dep_url, "user": user, "repo": repo, "version": ""}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
self.install_addon(unmet, dep_url, dep['full_name'], master=True)
return True
return False
for unmet in self.unmet_addons:
# Now attempt to locate dependencies from available sources
# The addons that can be found in any enabled repos will be installed at the end.
# check if this exists in users root repo
if kodi.get_setting('source_user') == 'true':
if user_resolver(user, unmet): continue
# check if this exists in tva root repo
if kodi.get_setting('source_tva') == 'true':
if user_resolver(tva_user, unmet): continue
# check if this exists on github
if kodi.get_setting('source_github') == 'true':
if github_resolver(unmet): continue
self.unmet_addons = list(set(self.unmet_addons) - set(self.met_addons))
if len(self.unmet_addons):
self.install_error = True
if not self.quiet:
kodi.close_busy_dialog()
kodi.raise_error("", "Unmet Dependencies:", "See log or install manually", ','.join(self.unmet_addons))
kodi.log("Unmet Dependencies for addon install: %s" % addon_id) # % self.addon_id)
kodi.log(','.join(self.unmet_addons))
self.completed.append(addon_id)
def settings_menu():
kodi.add_menu_item({'mode': 'update_addons'}, {'title': "Check for Updates [COLOR red](Advanced)[/COLOR]"}, icon='update.png', visible=kodi.get_setting('enable_updates') == 'true')
kodi.add_menu_item({'mode': 'addon_settings'}, {'title': "Addon Settings"}, icon='settings.png')
kodi.eod()
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*'''
import urllib
import traceback
from commoncore import kodi
from commoncore.baseapi import DB_CACHABLE_API as BASE_API, EXPIRE_TIMES
try:
_username = kodi.get_setting('premiumize_username', 'script.module.scrapecore')
_password = kodi.get_setting('premiumize_password', 'script.module.scrapecore')
except:
_username = ''
_password = ''
class PremiumizeAPI_V1(BASE_API):
'''
errors to be expected:
* 400 (no valid link)
* 401 (login failed)
* 402 (payment required - the download would be possible, but the account is not premium)
* 403 (forbidden) * 404 (file not found - the file has been deleted by a 3rd party provider)
* 428 (hoster currently not available. )
* 502 (unkonwn technical error (most likely from a 3rd party provieder - retry after some minutes, we recomend 3 minutes))
* 503 (temporary technical error, maintenance - retry after some minutes, we recomend 3 minutes),
PERIOD_OPTIONS = ["weekly" , "monthly" , "yearly" , "all"]
MEDIA_TYPES = ["movie" , "show" , "episode" , "person" , "list"]
ID_TYPES = ["trakt" , "imdb" , "tmdb" , "tvdb" , "tvrage"]
COMMON_FILTERS = ["query", "years", "genres", "languages", "countries", "runtimes", "ratings"]
MOVIE_FILTERS = COMMON_FILTERS + ["certifications"]
SHOW_FILTERS = COMMON_FILTERS + ["certifications", "networks", "status"]
SHOW_STATUS = ["returning series", "in production", "planned", "canceled", "ended"]
DAYS_TO_GET = 21
SHOW_GENRES = [(u'Action', u'action'), (u'Adventure', u'adventure'), (u'Animation', u'animation'), (u'Anime', u'anime'), (u'Biography', u'biography'), (u'Children', u'children'), (u'Comedy', u'comedy'), (u'Crime', u'crime'), (u'Disaster', u'disaster'), (u'Documentary', u'documentary'), (u'Drama', u'drama'), (u'Eastern', u'eastern'), (u'Family', u'family'), (u'Fantasy', u'fantasy'), (u'Game Show', u'game-show'), (u'History', u'history'), (u'Holiday', u'holiday'), (u'Home And Garden', u'home-and-garden'), (u'Horror', u'horror'), (u'Mini Series', u'mini-series'), (u'Music', u'music'), (u'Musical', u'musical'), (u'Mystery', u'mystery'), (u'News', u'news'),(u'Reality', u'reality'), (u'Romance', u'romance'), (u'Science Fiction', u'science-fiction'), (u'Short', u'short'), (u'Soap', u'soap'), (u'Sports', u'sports'), (u'Superhero', u'superhero'), (u'Suspense', u'suspense'), (u'Talk Show', u'talk-show'), (u'Thriller', u'thriller'), (u'War', u'war'), (u'Western', u'western')]
MOVIE_GENRES = [(u'Action', u'action'), (u'Adventure', u'adventure'), (u'Animation', u'animation'), (u'Anime', u'anime'), (u'Comedy', u'comedy'), (u'Crime', u'crime'), (u'Disaster', u'disaster'), (u'Documentary', u'documentary'), (u'Drama', u'drama'), (u'Eastern', u'eastern'), (u'Family', u'family'), (u'Fan Film', u'fan-film'), (u'Fantasy', u'fantasy'), (u'Film Noir', u'film-noir'), (u'History', u'history'), (u'Holiday', u'holiday'), (u'Horror', u'horror'), (u'Indie', u'indie'), (u'Music', u'music'), (u'Musical', u'musical'), (u'Mystery', u'mystery'), (u'Road', u'road'), (u'Romance', u'romance'), (u'Science Fiction', u'science-fiction'), (u'Short', u'short'), (u'Sports', u'sports'), (u'Superhero', u'superhero'), (u'Suspense', u'suspense'), (u'Thriller', u'thriller'), (u'Tv Movie', u'tv-movie'), (u'War', u'war'), (u'Western', u'western')]
class TraktException(Exception):
pass
CLIENT_ID = "d4161a7a106424551add171e5470112e4afdaf2438e6ef2fe0548edc75924868"
try:
AUTH_TOKEN = json.loads(kodi.get_setting('authorization', 'script.trakt'))['access_token']
except:
AUTH_TOKEN = '' #raise TraktException("Addon: script.trakt required.")
def to_slug(username):
username = username.strip()
username = username.lower()
username = re.sub('[^a-z0-9_]', '-', username)
username = re.sub('--+', '-', username)
return username
DB_TYPE = 'MySQL' if kodi.get_setting('database_type') == '1' else 'SQLite'
if DB_TYPE == 'MySQL':
from commoncore.baseapi import MYSQL_CACHABLE_API, EXPIRE_TIMES
