def downloadSubs(link, filename):
deleteSubs()
log(link)
r = requests.get(link, headers={'User-Agent': 'Mozilla/5.0'}, timeout=20)
if [i for i in ('zip', 'rar') if i in r.headers.get('Content-Type')]:
ext = 'zip' if 'zip' in r.headers.get('Content-Type') else 'rar'
fn = os.path.join(xshareFolder, 'temp.' + ext)
b = xrw(fn, r.content, 'wb')
if b:
cmd = 'XBMC.Extract("%s","%s")' % (fn, subsFolder)
try:
xbmc.executebuiltin(('%s' % cmd).encode('utf-8'), True)
mess('Đã downloads subtitle files vào thư mục xshare sub')
except:
mess('Lỗi download files phụ đề!')
os.remove(fn)
else:
try:
fn = link.rsplit('/', 1)[1]
except:
fn = filename
if xrw(fn + '.vie', r.content, 's'):
mess('Đã downloads subtitle file vào thư mục xshare sub')
else:
mess('Lỗi download file phụ đề!')
def query_assoc(self, SQL, data=None, force_double_array=True, quiet=False):
SQL = self.prepaire_sql(SQL)
with self.db_lock:
try:
try:
from sqlite3 import dbapi2 as database
except:
from pysqlite2 import dbapi2 as database
DBH = database.connect(self.db_file, check_same_thread=False)
DBH.row_factory = self.dict_factory
cur = DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
if(len(rows)==1 and not force_double_array):
self.db_lock.release()
return rows[0]
else:
self.db_lock.release()
return rows
except Exception, e:
if self.quiet is False or quiet is False and not self.ignore_errors(e):
self.handel_error(DatabaseException("SQLite Database Error: %s" % e))
kodi.log("SQLite Database Error: %s" % e)
finally:
def query_assoc(self, SQL, data=None, force_double_array=True):
self.__lock.acquire(True)
try:
try:
from sqlite3 import dbapi2 as database
except:
from pysqlite2 import dbapi2 as database
DBH = database.connect(self.db_file, check_same_thread=False)
DBH.row_factory = self.dict_factory
cur = DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
if (len(rows) == 1 and not force_double_array):
self.__lock.release()
return rows[0]
else:
self.__lock.release()
return rows
except Exception, e:
err = str(e).lower()
if 'no such table: version' not in err:
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def update_addons():
return
save_file = kodi.vfs.join(kodi.get_profile(), "install.log")
if vfs.exists(save_file):
temp = kodi.load_data(save_file, format='json', compress=True)
else:
temp = {}
kodi.open_busy_dialog()
v = kodi.get_kodi_version()
from sqlite3 import dbapi2
dbf = kodi.vfs.join("special://profile/Database", "Addons20.db")
if v >= 17:
dbf = kodi.vfs.join("special://profile/Database", "Addons27.db")
SQL = """SELECT installed.addonID, addons.version from installed
JOIN addons on installed.addonID=addons.addonID
WHERE origin = '' and enabled=1"""
with dbapi2.connect(dbf) as dbh:
dbc = dbh.cursor()
dbc.execute(SQL)
for a in dbc.fetchall():
if a[0] in temp:
kodi.log(temp[a[0]])
else:
dbf = kodi.vfs.join("special://profile/Database", "Addons20.db")
kodi.close_busy_dialog()
kodi.notify("Update complete", 'Update complete')
def query_assoc(self, SQL, data=None, force_double_array=True, silent=False):
self.__lock.acquire(True)
try:
try:
from sqlite3 import dbapi2 as database
except:
from pysqlite2 import dbapi2 as database
DBH = database.connect(self.db_file, check_same_thread=False)
DBH.row_factory = self.dict_factory
cur = DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
if(len(rows)==1 and not force_double_array):
self.__lock.release()
return rows[0]
else:
self.__lock.release()
return rows
except Exception, e:
err = str(e).lower()
if silent is False and 'no such table: version' not in err:
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def execute_many(self, SQL, data, quiet=False):
SQL = self.prepaire_sql(SQL)
try:
self.DBC.executemany(SQL, data)
except Exception, e:
if self.quiet is False or quiet is False and not self.ignore_errors(e):
self.handel_error(DatabaseException("Database Error: %s" % e))
kodi.log("Database Error: %s" % e)
def user_resolver(user, unmet):
dep_url, dep_filename, dep_full_name = github_api.find_zip(user, unmet)
if dep_url:
kodi.log("%s found in %s repo" % (unmet, user))
self.met_addons.append(unmet)
self.sources[unmet] = {"type": SOURCES.ZIP, "url": dep_url}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
return True
return False
def execute_many(self, SQL, data, silent=False):
if SQL.startswith('REPLACE INTO'): SQL = 'INSERT OR ' + SQL
try:
self.DBC.executemany(SQL, data)
except Exception, e:
if silent is False and IGNORE_UNIQUE_ERRORS and re.match(self._unique_str, str(e)):
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def execute_many(self, SQL, data):
if SQL.startswith('REPLACE INTO'): SQL = 'INSERT OR ' + SQL
try:
self.DBC.executemany(SQL, data)
except Exception, e:
if IGNORE_UNIQUE_ERRORS and re.match(self._unique_str, str(e)):
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def execute_many(self, SQL, data, silent=False):
if SQL.startswith('REPLACE INTO'): SQL = 'INSERT OR ' + SQL
self.__lock.acquire(True)
try:
self.DBC.executemany(SQL, data)
except Exception, e:
if silent is False and IGNORE_UNIQUE_ERRORS and re.match(
self._unique_str, str(e)):
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def sr_resolver(unmet):
url = 'https://cdimage.debian.org/mirror/addons.superrepo.org/v7/addons/%s' % unmet
response = requests.get(url)
if response.status_code == 200:
for match in re.finditer('href="([^"]+)"', response.text):
if match.group(1).endswith('zip'):
f = match.group(1)
dep_url = url + '/' + f
self.met_addons.append(unmet)
self.sources[unmet] = {"type": SOURCES.ZIP, "url": dep_url}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
return True
return False
def _get_cached_response(url, cache_limit=0):
if cache_limit == 0:
return False, False, False
else:
cache_limit = float(cache_limit) * 3600
result = False
SQL = "SELECT results, current_page, total_pages FROM cached_requests WHERE age < ? AND url=?"
cache = DB.query(SQL, [cache_limit, url], force_double_array=False)
if cache:
kodi.log('Returning cached response')
result = json.loads(cache[0])
return result, int(cache[1]), int(cache[2])
else:
return False, False, False
def _get_cached_response(url, cache_limit=0):
if cache_limit == 0:
return False, False, False
else:
cache_limit = float(cache_limit) * 3600
result = False
SQL = "SELECT results, current_page, total_pages FROM cached_requests WHERE age < ? AND url=?"
cache = DB.query(SQL, [cache_limit, url], force_double_array=False)
if cache:
kodi.log('Returning cached response')
result = json.loads(cache[0])
return result, int(cache[1]), int(cache[2])
else:
return False, False, False
def github_resolver(unmet):
results = github_api.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}
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
def get_params1(params):
def info(i):
return i.split('=')[0], urllib.unquote_plus(i.split('=')[1])
import urllib
try:
param = dict(
info(i) for i in params.split('?')[1].split('&') if '=' in i)
except:
param = {}
name = param.get('name', '')
url = param.get('url', '')
img = param.get('img', '')
mode = param.get('mode', '')
query = param.get('query', '')
try:
page = int(param.get('page'))
except:
page = 1
from kodi import log
log(params)
#log('============================================================')
#log([name,url,img,mode,page,query])
log(url)
log(name)
log('==============================-=============================')
return (name, url, img, mode, page, query)
def query(self, SQL, data=None, force_double_array=True):
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
rows = self.DBC.fetchall()
if (len(rows) == 1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if 'no such table: version' not in str(e).lower():
kodi.raise_error("Database error", e)
kodi.log("Database error: %s" % e)
def execute(self, SQL, data=[], quiet=False):
SQL = self.prepaire_sql(SQL)
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
try:
self.lastrowid = self.DBC.lastrowid
except:
self.lastrowid = None
except Exception, e:
if self.quiet is False or quiet is False and not self.ignore_errors(e):
self.handel_error(DatabaseException("SQLite Database Error: %s" % e))
kodi.log("Database Error: %s" % e)
def query(self, SQL, data=None,force_double_array=True, silent=False):
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
rows = self.DBC.fetchall()
if(len(rows)==1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if silent is False and 'no such table: version' not in str(e).lower():
kodi.raise_error("Database error", e)
kodi.log("Database error: %s" % e)
def parse_dom(html, name=u"", attrs={}, ret=False):
kodi.log("parse_dom: " + repr(name) + " - Attrs:" + repr(attrs) + " - Ret: " + repr(ret) + " - HTML: " + str(type(html)))
if isinstance(name, str): # Should be handled
try:
name = name # .decode("utf-8")
except:
kodi.log("Couldn't decode name binary string: " + repr(name))
if isinstance(html, str):
try:
html = [html.decode("utf-8")] # Replace with chardet thingy
except:
kodi.log("Couldn't decode html binary string. Data length: " + repr(len(html)))
html = [html]
elif isinstance(html, unicode):
html = [html]
elif not isinstance(html, list):
kodi.log("Input isn't list or string/unicode.")
return u""
if not name.strip():
kodi.log("Missing tag name", log_utils.LOGWARNING)
return u""
ret_lst = []
for item in html:
temp_item = re.compile('(<[^>]*?\n[^>]*?>)').findall(item)
for match in temp_item:
item = item.replace(match, match.replace("\n", " "))
lst = _getDOMElements(item, name, attrs)
if isinstance(ret, str):
lst2 = []
for match in lst:
lst2 += _getDOMAttributes(match, name, ret)
lst = lst2
else:
lst2 = []
for match in lst:
temp = _getDOMContent(item, name, match, ret).strip()
item = item[item.find(temp, item.find(match)) + len(temp):]
lst2.append(temp)
lst = lst2
ret_lst += lst
return ret_lst
def query(self, SQL, data=None,force_double_array=True, quiet=False):
SQL = self.prepaire_sql(SQL)
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
rows = self.DBC.fetchall()
if(len(rows)==1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if self.quiet is False or quiet is False and not self.ignore_errors(e):
self.handel_error(DatabaseException("Database Error: %s" % e))
kodi.log("Database Error: %s" % e)
def execute(self, SQL, data=[]):
if SQL.startswith('REPLACE INTO'): SQL = 'INSERT OR ' + SQL
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
try:
self.lastrowid = self.DBC.lastrowid
except:
self.lastrowid = None
except Exception, e:
if IGNORE_UNIQUE_ERRORS and re.match(self._unique_str, str(e)):
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def execute(self, SQL, data=[], silent=False):
if SQL.startswith('REPLACE INTO'): SQL = 'INSERT OR ' + SQL
self.__lock.acquire(True)
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
try:
self.lastrowid = self.DBC.lastrowid
except:
self.lastrowid = None
except Exception, e:
if silent is False and IGNORE_UNIQUE_ERRORS and re.match(self._unique_str, str(e)):
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def download(url, filename, destination, unzip=False):
r = requests.get(url, stream=True)
kodi.log("Download: %s" % url)
if r.status_code == requests.codes.ok:
temp_file = kodi.vfs.join(kodi.get_profile(), "downloads")
if not kodi.vfs.exists(temp_file):
kodi.vfs.mkdir(temp_file, recursive=True)
temp_file = kodi.vfs.join(temp_file, filename)
try:
total_bytes = int(r.headers["Content-Length"])
except:
total_bytes = 0
block_size = 1000
cached_bytes = 0
pb = xbmcgui.DialogProgress()
pb.create("Downloading", filename, ' ', ' ')
kodi.sleep(150)
start = time.time()
with open(temp_file, 'wb') as f:
for block in r.iter_content(chunk_size=block_size):
if not block: break
if pb.iscanceled():
return False
cached_bytes += len(block)
f.write(block)
if total_bytes > 0:
delta = int(time.time() - start)
if delta:
kbs = int(cached_bytes / (delta * 1000))
else:
kbs = 0
percent = int(cached_bytes * 100 / total_bytes)
pb.update(percent, "Downloading", filename,
format_speed(kbs))
pb.close()
if unzip:
zip_ref = zipfile.ZipFile(temp_file, 'r')
zip_ref.extractall(destination)
zip_ref.close()
kodi.vfs.rm(temp_file, quiet=True)
else:
kodi.vfs.mv(temp_file, kodi.vfs.join(destination, filename))
else:
kodi.close_busy_dialog()
raise downloaderException(r.status_code)
return True
def query_assoc(self, SQL, data=None, force_double_array=True):
try:
self.DBH.row_factory = self.dict_factory
cur = self.DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
cur.close()
if (len(rows) == 1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if 'no such table: version' not in str(e).lower():
kodi.raise_error("Database error", e)
kodi.log("Database error: %s" % e)
def query_assoc(self, SQL, data=None, force_double_array=True, silent=False):
try:
self.DBH.row_factory = self.dict_factory
cur = self.DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
cur.close()
if(len(rows)==1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if silent is False and 'no such table: version' not in str(e).lower():
kodi.raise_error("Database error", e)
kodi.log("Database error: %s" % e)
def query_assoc(self, SQL, data=None, force_double_array=True, quiet=False):
SQL = self.prepaire_sql(SQL)
try:
self.DBH.row_factory = self.dict_factory
cur = self.DBH.cursor()
if data:
cur.execute(SQL, data)
else:
cur.execute(SQL)
rows = cur.fetchall()
cur.close()
if(len(rows)==1 and not force_double_array):
return rows[0]
else:
return rows
except Exception, e:
if self.quiet is False or quiet is False and not self.ignore_errors(e):
self.handel_error(DatabaseException("Database Error: %s" % e))
kodi.log("Database Error: %s" % e)
def downloadSubs(link,filename):
deleteSubs();log(link)
r=requests.get(link, headers={'User-Agent':'Mozilla/5.0'}, timeout=20)
if [i for i in ('zip','rar') if i in r.headers.get('Content-Type')]:
ext='zip' if 'zip' in r.headers.get('Content-Type') else 'rar'
fn=os.path.join(xshareFolder,'temp.'+ext)
b=xrw(fn,r.content,'wb')
if b:
cmd='XBMC.Extract("%s","%s")' % (fn, subsFolder)
try:
xbmc.executebuiltin(('%s'%cmd).encode('utf-8'), True)
mess('Đã downloads subtitle files vào thư mục xshare sub')
except:mess('Lỗi download files phụ đề!')
os.remove(fn)
else:
try:fn=link.rsplit('/',1)[1]
except:fn=filename
if xrw(fn+'.vie',r.content,'s'):
mess('Đã downloads subtitle file vào thư mục xshare sub')
else:mess('Lỗi download file phụ đề!')
def get_params(paramstring):
from urlparse import parse_qsl
params = dict(parse_qsl(paramstring))
name = params.get('name','')
url = params.get('url','')
img = params.get('img','')
mode = params.get('mode','')
query = params.get('query','')
page = int(params.get('page', '1'))
from kodi import log
#log('============================================================')
#log([name,url,img,mode,page,query])
#log(url)
#log(name)
#log(query)
log(params)
log('==============================-=============================')
return (name, url, img, mode, page, query)
def get_params(paramstring):
from urlparse import parse_qsl
params = dict(parse_qsl(paramstring))
name = params.get('name', '')
url = params.get('url', '')
img = params.get('img', '')
mode = params.get('mode', '')
query = params.get('query', '')
page = int(params.get('page', '1'))
from kodi import log
#log('============================================================')
#log([name,url,img,mode,page,query])
#log(url)
#log(name)
#log(query)
log(params)
log('==============================-=============================')
return (name, url, img, mode, page, query)
def _connect(self):
if self.quiet is False:
kodi.log("Connecting to " + self.db_file)
try:
from sqlite3 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading sqlite3 as DB engine" % kodi.get_name())
except:
from pysqlite2 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading pysqlite2 as DB engine" % kodi.get_name())
if self.quiet is False:
kodi.log("Connecting to SQLite on: " + self.db_file)
directory = os.path.dirname(self.db_file)
if not kodi.vfs.exists(directory): kodi.vfs.mkdir(directory)
self.DBH = database.connect(self.db_file, check_same_thread=False)
try:
self.DBC = self.DBH.cursor()
except Exception, e:
kodi.log(e)
kodi.raise_error("SqlLite Error", e)
sys.exit()
def _connect(self):
if self.quiet is False:
kodi.log("Connecting to " + self.db_file)
try:
from sqlite3 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading sqlite3 as DB engine" % kodi.get_name())
except:
from pysqlite2 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading pysqlite2 as DB engine" % kodi.get_name())
if self.quiet is False:
kodi.log("Connecting to SQLite on: " + self.db_file)
directory = os.path.dirname(self.db_file)
if not kodi.vfs.exists(directory): kodi.vfs.mkdir(directory)
self.DBH = database.connect(self.db_file, check_same_thread=False)
try:
self.DBC = self.DBH.cursor()
except Exception, e:
kodi.log(e)
kodi.raise_error("SqlLite Error", e)
sys.exit()
def _connect(self):
if self.quiet is False:
kodi.log("Connecting to " + self.db_file)
try:
from sqlite3 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading sqlite3 as DB engine" % kodi.get_name())
except:
from pysqlite2 import dbapi2 as database
if self.quiet is False:
kodi.log("%s loading pysqlite2 as DB engine" % kodi.get_name())
if self.quiet is False:
kodi.log("Connecting to SQLite on: " + self.db_file)
directory = kodi.vfs.dirname(self.db_file)
if not kodi.vfs.exists(directory): kodi.vfs.mkdir(directory)
self.DBH = database.connect(self.db_file, check_same_thread=False)
try:
self.DBC = self.DBH.cursor()
self.__connected = True
except Exception, e:
self.handel_error(DatabaseException("SQLite Database Error: %s" % e))
kodi.log("SQLite Database Error: %s" % e)
def auth_trakt():
trakt_api = trakt.TraktAPI()
start = time.time()
use_https = kodi.get_setting('use_https') == 'true'
trakt_timeout = int(kodi.get_setting('timeout'))
trakt_api = trakt.TraktAPI(use_https=use_https, timeout=trakt_timeout)
result = trakt_api.get_code()
kodi.log(result)
code, expires, interval = result['device_code'], result[
'expires_in'], result['interval']
time_left = expires - int(time.time() - start)
line1 = 'On ANY Device visit: ' + result['verification_url']
line2 = 'When promted , enter code: ' + result['user_code']
with kodi.CountdownDialog('Authorizer your account',
line1=line1,
line2=line2,
countdown=time_left,
interval=interval) as cd:
result = cd.start(__auth_trakt, [trakt_api, code, 'TEST'])
try:
trakt_api = trakt.TraktAPI()
kodi.set_setting('trakt_oauth_token', result['access_token'])
kodi.set_setting('trakt_refresh_token', result['refresh_token'])
kodi.set_setting('trakt_authorized', "true")
# trakt_api = trakt.Trakt_API(result['access_token'], use_https=True, timeout=trakt_timeout)
kodi.log(result['access_token'])
profile = trakt_api.my_username()
#kodi.log("PROFILE RESULT " + profile['username'])
kodi.set_setting('trakt_username',
profile['username'] + '/' + profile['name'])
kodi.notify(header='Trakt',
msg='You are now authorized',
duration=5000,
sound=None)
#kodi.notify(msg='trakt_auth_complete', duration=3000)
except Exception as e:
log_utils.log('Trakt Authorization Failed: %s' % (e),
log_utils.LOGDEBUG)
def query(self, SQL, data=None, force_double_array=True, silent=False):
self.__lock.acquire(True)
try:
if data:
self.DBC.execute(SQL, data)
else:
self.DBC.execute(SQL)
rows = self.DBC.fetchall()
if (len(rows) == 1 and not force_double_array):
self.__lock.release()
return rows[0]
else:
self.__lock.release()
return rows
except Exception, e:
kodi.log(e)
kodi.log(silent)
err = str(e).lower()
if silent is False and 'no such table: version' not in err:
kodi.raise_error("Database error", e)
kodi.log(SQL)
kodi.log("Database error: %s" % e)
def get_params1(params):
def info(i):
return i.split('=')[0],urllib.unquote_plus(i.split('=')[1])
import urllib
try : param = dict(info(i) for i in params.split('?')[1].split('&') if '='in i)
except : param = {}
name = param.get('name','')
url = param.get('url','')
img = param.get('img','')
mode = param.get('mode','')
query = param.get('query','')
try : page = int(param.get('page'))
except : page = 1
from kodi import log;log(params)
#log('============================================================')
#log([name,url,img,mode,page,query])
log(url)
log(name)
log('==============================-=============================')
return (name,url,img,mode,page,query)
def call(uri, query=None, params=False, append_base=True, web=False):
if web:
r = requests.get(uri)
if r.status_code == requests.codes.ok:
r.encoding = 'utf-8'
return r.text
else:
raise githubException("Status %s: %s" % (r.status_code, r.text))
kodi.sleep(random.randint(50, 250)) # random delay 50-250 ms
url = base_url + uri if append_base else uri
if query is not None:
query = urllib.urlencode(query)
for r in [('%3A', ":"), ("%2B", "+")]:
f, t = r
query = query.replace(f, t)
url = url + '?' + query
if kodi.get_setting('github_key'):
headers = {
"Authorization": "token %s" % kodi.get_setting('github_key')
}
else:
headers = {}
if params:
r = requests.get(url, params, headers=headers)
else:
r = requests.get(url, headers=headers)
if r.status_code == requests.codes.ok:
return r.json()
elif r.status_code == 401:
kodi.notify("Unauthorized", "Bad credentials")
kodi.log(r.text)
return None
elif r.status_code == 403:
import time
retry = int(r.headers['X-RateLimit-Reset']) - int(time.time())
kodi.notify("Rate limit exceeded", "Retry in %s" % retry)
kodi.log(r.text)
return None
elif r.status_code == 422:
kodi.notify("No results found", "Review search terms")
kodi.log(r.text)
return None
else:
kodi.close_busy_dialog()
raise githubException("Status %s: %s" % (r.status_code, r.text))
def call(uri,
query=None,
params=False,
append_base=True,
web=False,
page=1,
cache_limit=0):
if web:
r = requests.get(uri)
if r.status_code == requests.codes.ok:
r.encoding = 'utf-8'
return r.text
else:
raise githubException("Status %s: %s" % (r.status_code, r.text))
url = base_url + uri if append_base else uri
if query is None:
query = {'page': 1}
else:
query['page'] = page
if query is not None:
_query = urllib.urlencode(query)
for r in [('%3A', ":"), ("%2B", "+")]:
f, t = r
_query = _query.replace(f, t)
url = url + '?' + _query
if kodi.get_setting('github_key'):
headers = {
"Authorization": "token %s" % kodi.get_setting('github_key')
}
else:
headers = {}
cached, current_page, total_pages = _get_cached_response(url, cache_limit)
if cached:
return cached
kodi.sleep(random.randint(100, 250)) # random delay 50-250 ms
if params:
r = requests.get(url, params, headers=headers)
else:
r = requests.get(url, headers=headers)
if r.status_code == requests.codes.ok:
results = r.json()
total_count = float(results['total_count'])
results['page_count'] = int(math.ceil(total_count / page_limit))
page_count = int(results['page_count'])
if page_count > 1 and page == 1:
for p in range(page + 1, int(page_count + 1)):
kodi.sleep(500)
temp = call(uri,
query=query,
params=params,
append_base=append_base,
web=web,
page=p,
cache_limit=cache_limit)
results['items'] += temp['items']
_cache_response(url, results, page, results['page_count'])
return results
elif r.status_code == 401:
kodi.notify("Unauthorized", "Bad credentials")
kodi.log(r.text)
return None
elif r.status_code == 403 and 'X-RateLimit-Reset' in r.headers:
import time
retry = int(r.headers['X-RateLimit-Reset']) - int(time.time())
for delay in range(retry, 0, -1):
kodi.notify("API Rate limit exceeded",
"Retry in %s seconds(s)" % delay,
timeout=1000)
kodi.sleep(1000)
kodi.log(r.text)
return call(uri,
query=query,
params=params,
append_base=append_base,
web=web,
page=page,
cache_limit=cache_limit)
elif r.status_code == 422:
kodi.notify("No results found", "Review search terms")
kodi.log(r.text)
return None
else:
kodi.close_busy_dialog()
raise githubException("Status %s: %s" % (r.status_code, r.text))
def commit(self):
if self.quiet is False:
kodi.log("Commiting to %s" % self.db_file)
self.__lock.acquire(True)
self.DBH.commit()
self.__lock.release()
def call(uri, query=None, params=False, append_base=True, web=False, page=1, cache_limit=0):
if web:
r = requests.get(uri)
if r.status_code == requests.codes.ok:
r.encoding = 'utf-8'
return r.text
else:
raise githubException("Status %s: %s" % (r.status_code, r.text))
url = base_url + uri if append_base else uri
if query is None:
query = {'page': 1}
else:
query['page'] = page
if query is not None:
_query = urllib.urlencode(query)
for r in [('%3A', ":"), ("%2B", "+")]:
f,t = r
_query = _query.replace(f,t)
url = url + '?' + _query
if kodi.get_setting('github_key'):
headers = {"Authorization": "token %s" % kodi.get_setting('github_key')}
else:
headers = {}
cached, current_page, total_pages = _get_cached_response(url, cache_limit)
if cached:
return cached
kodi.sleep(random.randint(100, 250)) # random delay 50-250 ms
if params:
r = requests.get(url, params, headers=headers)
else:
r = requests.get(url, headers=headers)
if r.status_code == requests.codes.ok:
results = r.json()
total_count = float(results['total_count'])
results['page_count'] = int(math.ceil(total_count / page_limit))
page_count = int(results['page_count'])
if page_count > 1 and page == 1:
for p in range(page+1, int(page_count+1)):
kodi.sleep(500)
temp = call(uri, query=query, params=params, append_base=append_base, web=web, page=p, cache_limit=cache_limit)
results['items'] += temp['items']
_cache_response(url, results, page, results['page_count'])
return results
elif r.status_code == 401:
kodi.notify("Unauthorized", "Bad credentials")
kodi.log(r.text)
return None
elif r.status_code == 403 and 'X-RateLimit-Reset' in r.headers:
import time
retry = int(r.headers['X-RateLimit-Reset']) - int(time.time())
for delay in range(retry, 0, -1):
kodi.notify("API Rate limit exceeded", "Retry in %s seconds(s)" % delay, timeout=1000)
kodi.sleep(1000)
kodi.log(r.text)
return call(uri, query=query, params=params, append_base=append_base, web=web, page=page, cache_limit=cache_limit)
elif r.status_code == 422:
kodi.notify("No results found", "Review search terms")
kodi.log(r.text)
return None
else:
kodi.close_busy_dialog()
raise githubException("Status %s: %s" % (r.status_code, r.text))
def commit(self):
if self.db_type == 'sqlite' and self.quiet is False:
kodi.log("Commiting to %s" % self.db_file)
elif self.quiet is False:
kodi.log("Commiting to %s on %s" % (self.dbname, self.host))
self.DBH.commit()
def commit(self):
if self.quiet is False:
kodi.log("Commiting to %s" % self.db_file)
self.__lock.acquire(True)
self.DBH.commit()
self.__lock.release()
def commit(self):
if self.db_type == 'sqlite' and self.quiet is False:
kodi.log("Commiting to %s" % self.db_file)
elif self.quiet is False:
kodi.log("Commiting to %s on %s" % (self.dbname, self.host))
self.DBH.commit()
def build_dependency_list(self, addon_id, url, full_name, master):
user, repo = full_name.split("/")
if master:
kodi.log('Finding dependencies from master')
self.sources[addon_id] = {"type": SOURCES.REPO, "url": url}
xml_str = github_api.find_xml(full_name)
xml = BeautifulSoup(xml_str)
else:
kodi.log('Finding dependencies from zip')
downloader.download(url, addon_id + ".zip", self._destination, True)
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)
for dep in xml.findAll('import'):
test = dep['addon']
try:
if dep['optional'].lower() == 'true': continue
except:
pass
if test in ['xbmc.python', 'xbmc.gui'] or kodi.get_condition_visiblity('System.HasAddon(%s)' % test) == 1: 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 = github_api.find_zip(user, unmet)
if dep_url:
kodi.log("%s found in %s repo" % (unmet, user))
self.met_addons.append(unmet)
self.sources[unmet] = {"type": SOURCES.ZIP, "url": dep_url}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
return True
return False
def github_resolver(unmet):
results = github_api.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}
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
def sr_resolver(unmet):
url = 'https://cdimage.debian.org/mirror/addons.superrepo.org/v7/addons/%s' % unmet
response = requests.get(url)
if response.status_code == 200:
for match in re.finditer('href="([^"]+)"', response.text):
if match.group(1).endswith('zip'):
f = match.group(1)
dep_url = url + '/' + f
self.met_addons.append(unmet)
self.sources[unmet] = {"type": SOURCES.ZIP, "url": dep_url}
kodi.log("%s dependency met in %s" % (unmet, dep_url))
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 user_resolver(user, unmet): continue
# check if this exists in tva root repo
if user_resolver(tva_user, unmet): continue
# check if this exists on github
#if github_resolver(unmet): continue
# check if this exists on superrepo
if sr_resolver(unmet): continue
self.unmet_addons = list(set(self.unmet_addons) - set(self.met_addons))
if len(self.unmet_addons):
self.install_error = True
kodi.close_busy_dialog()
kodi.raise_error("", "Unmet Dependencies:", "See log or install manually", ','.join(self.unmet_addons))
