def addDownload(name, url, image, provider=None):
try:
def download():
return []
result = cache.get(download, 600000000, table='rel_dl')
result = [i['name'] for i in result]
except:
pass
if name in result:
return control.infoDialog('Item Already In Your Queue', name)
from resources.lib.zindexers import kratos
url = kratos.resolver().link(url)
if url == None: return
try:
u = url.split('|')[0]
try:
headers = dict(urlparse.parse_qsl(url.rsplit('|', 1)[1]))
except:
headers = dict('')
ext = os.path.splitext(urlparse.urlparse(u).path)[1][1:].lower()
if ext == 'm3u8': raise Exception()
if not ext in ['mp4', 'm4a', 'mp3', 'aac', 'mkv', 'flv', 'avi', 'mpg']:
ext = 'mp4'
dest = name + '.' + ext
req = urllib2.Request(u, headers=headers)
resp = urllib2.urlopen(req, timeout=30)
size = int(resp.headers['Content-Length'])
size = ' %.2f GB' % (float(size) / 1073741824)
no = control.yesnoDialog(dest, 'Complete file is' + size,
'Continue with download?',
name + ' - ' + 'Confirm Download', 'Confirm',
'Cancel')
if no: return
except:
return control.infoDialog('Unable to download')
pass
def download():
return [{'name': name, 'url': url, 'image': image}]
result = cache.get(download, 600000000, table='rel_dl')
result = [i for i in result if not i['url'] == url]
def download():
return result + [{'name': name, 'url': url, 'image': image}]
result = cache.get(download, 0, table='rel_dl')
control.infoDialog('Item Added to Queue', name)
def removeDownload(url):
try:
def download():
return []
result = cache.get(download, 600000000, table='rel_dl')
if result == '': result = []
result = [i for i in result if not i['url'] == url]
if result == []: result = ''
def download():
return result
result = cache.get(download, 0, table='rel_dl')
control.refresh()
except:
control.infoDialog('You need to remove file manually',
'Can not remove from Queue')
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, year):
try:
if (self.user == '' or self.password == ''): raise Exception()
url = cache.get(self.ororo_tvcache, 120, self.user)
url = [i[0] for i in url if imdb == i[1]][0]
url = self.show_link % url
return url
except:
return
def movie(self, imdb, title, localtitle, year):
try:
if (self.user == '' or self.password == ''): raise Exception()
url = cache.get(self.ororo_moviecache, 60, self.user)
url = [i[0] for i in url if imdb == i[1]][0]
url = self.movie_link % url
return url
except:
return
def movie(self, imdb, title, localtitle, year):
try:
url = self.searchMovie(title, year)
if url == None:
t = cache.get(self.getImdbTitle, 900, imdb)
if t != title:
url = self.searchMovie(t, year)
return url
except:
return
def movie(self, imdb, title, localtitle, year):
try:
r = self.searchMovie(title)
if r == None:
t = cache.get(self.getImdbTitle, 900, imdb)
if t != title:
r = self.searchMovie(t)
return urllib.urlencode({'url': r, 'episode': 0})
except:
return
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, year):
try:
result = cache.get(self.onlinedizi_tvcache, 120)
tvshowtitle = cleantitle.get(tvshowtitle)
result = [i[0] for i in result if tvshowtitle == i[1]][0]
url = urlparse.urljoin(self.base_link, result)
url = urlparse.urlparse(url).path
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
return url
except:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
if 'tvshowtitle' in data:
r = self.searchShow(data['tvshowtitle'], season)
if r == None:
t = cache.get(self.getImdbTitle, 900, imdb)
if t != data['tvshowtitle']:
r = self.searchShow(t, season)
return urllib.urlencode({'url': r, 'episode': episode})
except:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
year = re.findall('(\d{4})', premiered)[0]
season = '%01d' % int(season)
episode = '%01d' % int(episode)
tvshowtitle = '%s %s: Season %s' % (data['tvshowtitle'], year,
season)
url = cache.get(self.pidtv_tvcache, 120, tvshowtitle)
if url == None: raise Exception()
url += '?episode=%01d' % int(episode)
url = url.encode('utf-8')
return url
except:
return
def request(self, endpoint, query = None):
try:
# Encode the queries, if there is any...
if (query != None):
query = '?' + urllib.urlencode(query)
else:
query = ''
# Make the request
request = self.api_url % (endpoint, query)
# Send the request and get the response
# Get the results from cache if available
response = cache.get(client.request, 24, request)
# Retrun the result as a dictionary
return json.loads(response)
except:
pass
return {}
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
if debrid.status() == False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['tvshowtitle']
season = '%01d' % int(data['season'])
episode = '%02d' % int(data['episode'])
r = cache.get(self.ddlseries_tvcache, 120)
r = [(i[0], i[3]) for i in r
if cleantitle.get(title) == cleantitle.get(i[1])
and season == i[2]]
links = []
for url, quality in r:
try:
link = client.request(url)
vidlinks = client.parseDOM(link,
'span',
attrs={'class': 'overtr'})[0]
match = re.compile('href="([^"]+)[^>]*>\s*Episode\s+(\d+)<'
).findall(vidlinks)
match = [(i[0], quality) for i in match if episode == i[1]]
links += match
except:
pass
for url, quality in links:
try:
if "protect-links" in url:
redirect = client.request(url)
url = re.findall('<a href="(.*?)" target="_blank">',
redirect)
url = url[0]
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(url.strip().lower()).netloc)[0]
if not host in hostprDict: raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': True
})
except:
pass
return sources
except:
return sources
def request(url, close=True, redirect=True, error=False, proxy=None, post=None, headers=None, mobile=False, XHR=False, limit=None, referer=None, cookie=None, output='', timeout='30'):
try:
handlers = []
if not proxy == None:
handlers += [urllib2.ProxyHandler({'http':'%s' % (proxy)}), urllib2.HTTPHandler]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
if output == 'cookie' or output == 'extended' or not close == True:
cookies = cookielib.LWPCookieJar()
handlers += [urllib2.HTTPHandler(), urllib2.HTTPSHandler(), urllib2.HTTPCookieProcessor(cookies)]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
try:
if sys.version_info < (2, 7, 9): raise Exception()
import ssl; ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
handlers += [urllib2.HTTPSHandler(context=ssl_context)]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
except:
pass
try: headers.update(headers)
except: headers = {}
if 'User-Agent' in headers:
pass
elif not mobile == True:
#headers['User-Agent'] = agent()
headers['User-Agent'] = cache.get(randomagent, 1)
else:
headers['User-Agent'] = 'Apple-iPhone/701.341'
if 'Referer' in headers:
pass
elif referer == None:
headers['Referer'] = '%s://%s/' % (urlparse.urlparse(url).scheme, urlparse.urlparse(url).netloc)
else:
headers['Referer'] = referer
if not 'Accept-Language' in headers:
headers['Accept-Language'] = 'en-US'
if 'X-Requested-With' in headers:
pass
elif XHR == True:
headers['X-Requested-With'] = 'XMLHttpRequest'
if 'Cookie' in headers:
pass
elif not cookie == None:
headers['Cookie'] = cookie
if redirect == False:
class NoRedirection(urllib2.HTTPErrorProcessor):
def http_response(self, request, response): return response
opener = urllib2.build_opener(NoRedirection)
opener = urllib2.install_opener(opener)
try: del headers['Referer']
except: pass
request = urllib2.Request(url, data=post, headers=headers)
try:
response = urllib2.urlopen(request, timeout=int(timeout))
except urllib2.HTTPError as response:
if response.code == 503:
cf_result = response.read(5242880)
try: encoding = response.info().getheader('Content-Encoding')
except: encoding = None
if encoding == 'gzip':
cf_result = gzip.GzipFile(fileobj=StringIO.StringIO(cf_result)).read()
if 'cf-browser-verification' in cf_result:
netloc = '%s://%s' % (urlparse.urlparse(url).scheme, urlparse.urlparse(url).netloc)
ua = headers['User-Agent']
cf = cache.get(cfcookie().get, 168, netloc, ua, timeout)
headers['Cookie'] = cf
request = urllib2.Request(url, data=post, headers=headers)
response = urllib2.urlopen(request, timeout=int(timeout))
elif error == False:
return
elif error == False:
return
if output == 'cookie':
try: result = '; '.join(['%s=%s' % (i.name, i.value) for i in cookies])
except: pass
try: result = cf
except: pass
if close == True: response.close()
return result
elif output == 'geturl':
result = response.geturl()
if close == True: response.close()
return result
elif output == 'headers':
result = response.headers
if close == True: response.close()
return result
elif output == 'chunk':
try: content = int(response.headers['Content-Length'])
except: content = (2049 * 1024)
if content < (2048 * 1024): return
result = response.read(16 * 1024)
if close == True: response.close()
return result
if limit == '0':
result = response.read(224 * 1024)
elif not limit == None:
result = response.read(int(limit) * 1024)
else:
result = response.read(5242880)
try: encoding = response.info().getheader('Content-Encoding')
except: encoding = None
if encoding == 'gzip':
result = gzip.GzipFile(fileobj=StringIO.StringIO(result)).read()
if 'sucuri_cloudproxy_js' in result:
su = sucuri().get(result)
headers['Cookie'] = su
request = urllib2.Request(url, data=post, headers=headers)
response = urllib2.urlopen(request, timeout=int(timeout))
if limit == '0':
result = response.read(224 * 1024)
elif not limit == None:
result = response.read(int(limit) * 1024)
else:
result = response.read(5242880)
try: encoding = response.info().getheader('Content-Encoding')
except: encoding = None
if encoding == 'gzip':
result = gzip.GzipFile(fileobj=StringIO.StringIO(result)).read()
if output == 'extended':
response_headers = response.headers
response_code = str(response.code)
try: cookie = '; '.join(['%s=%s' % (i.name, i.value) for i in cookies])
except: pass
try: cookie = cf
except: pass
if close == True: response.close()
return (result, response_code, response_headers, headers, cookie)
else:
if close == True: response.close()
return result
except:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
if not str(url).startswith('http'):
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data[
'title']
imdb = data['imdb']
year = data['year']
if 'tvshowtitle' in data:
url = '%s/tv-show/%s/season/%01d/episode/%01d' % (
self.base_link, cleantitle.geturl(title),
int(data['season']), int(data['episode']))
result = client.request(url, limit='5')
if result == None:
t = cache.get(self.getImdbTitle, 900, imdb)
if title != t:
url = '%s/tv-show/%s/season/%01d/episode/%01d' % (
self.base_link, cleantitle.geturl(t),
int(data['season']), int(data['episode']))
result = client.request(url, limit='5')
else:
url = '%s/movie/%s' % (self.base_link,
cleantitle.geturl(title))
result = client.request(url, limit='5')
if result == None:
t = cache.get(self.getImdbTitle, 900, imdb)
if title != t:
url = '%s/movie/%s' % (self.base_link,
cleantitle.geturl(t))
result = client.request(url, limit='5')
if result == None and not 'tvshowtitle' in data:
url += '-%s' % year
result = client.request(url, limit='5')
result = client.parseDOM(result, 'title')[0]
if '%TITLE%' in result: raise Exception()
r = client.request(url, output='extended')
if not imdb in r[0]: raise Exception()
else:
url = urlparse.urljoin(self.base_link, url)
r = client.request(url, output='extended')
cookie = r[4]
headers = r[3]
result = r[0]
try:
auth = re.findall('__utmx=(.+)', cookie)[0].split(';')[0]
except:
auth = 'false'
auth = 'Bearer %s' % urllib.unquote_plus(auth)
headers['Authorization'] = auth
headers[
'Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'
headers[
'Accept'] = 'application/json, text/javascript, */*; q=0.01'
headers['Cookie'] = cookie
headers['Referer'] = url
u = '/ajax/jne.php'
u = urlparse.urljoin(self.base_link, u)
action = 'getEpisodeEmb' if '/episode/' in url else 'getMovieEmb'
elid = urllib.quote(
base64.encodestring(str(int(time.time()))).strip())
token = re.findall("var\s+tok\s*=\s*'([^']+)", result)[0]
idEl = re.findall('elid\s*=\s*"([^"]+)', result)[0]
post = {
'action': action,
'idEl': idEl,
'token': token,
'elid': elid
}
post = urllib.urlencode(post)
c = client.request(u,
post=post,
headers=headers,
XHR=True,
output='cookie',
error=True)
headers['Cookie'] = cookie + '; ' + c
r = client.request(u, post=post, headers=headers, XHR=True)
r = str(json.loads(r))
r = re.findall('\'(http.+?)\'', r) + re.findall('\"(http.+?)\"', r)
for i in r:
try:
sources.append({
'source':
'gvideo',
'quality':
directstream.googletag(i)[0]['quality'],
'language':
'en',
'url':
i,
'direct':
True,
'debridonly':
False
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
if not str(url).startswith('http'):
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
if 'tvshowtitle' in data:
url = '%s/film/%s-season-%01d/watching.html' % (
self.base_link, cleantitle.geturl(
data['tvshowtitle']), int(data['season']))
url = client.request(url, timeout='10', output='geturl')
if url == None:
url = self.searchShow(data['tvshowtitle'],
data['season'])
if url == None:
t = cache.get(self.getImdbTitle, 900, data['imdb'])
if data['tvshowtitle'] != t:
url = self.searchShow(t, data['season'])
else:
url = '%s/film/%s/watching.html' % (
self.base_link, cleantitle.geturl(data['title']))
url = client.request(url, timeout='10', output='geturl')
if url == None:
url = self.searchMovie(data['title'])
if url == None:
t = cache.get(self.getImdbTitle, 900, data['imdb'])
if data['title'] != t:
url = self.searchMovie(t)
if url == None: raise Exception()
else:
url = urlparse.urljoin(self.base_link, url)
r = client.request(url, timeout='10')
r = client.parseDOM(r, 'div', attrs={'class': 'les-content'})
if 'tvshowtitle' in data:
ep = data['episode']
links = client.parseDOM(r,
'a',
attrs={'episode-data': ep},
ret='player-data')
else:
links = client.parseDOM(r, 'a', ret='player-data')
for link in links:
if '123movieshd' in link or 'seriesonline' in link:
r = client.request(link, timeout='10')
r = re.findall('(https:.*?redirector.*?)[\'\"]', r)
for i in r:
try:
sources.append({
'source':
'gvideo',
'quality':
directstream.googletag(i)[0]['quality'],
'language':
'en',
'url':
i,
'direct':
True,
'debridonly':
False
})
except:
pass
else:
try:
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(link.strip().lower()).netloc)[0]
if not host in hostDict: raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': link,
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
return sources
def run(self):
def download():
return []
result = cache.get(download, 600000000, table='rel_dl')
for item in result:
self.name = item['name']
self.image = item['image']
self.url = item['url']
sysname = self.name.translate(None, '\/:*?"<>|').strip('.')
url = self.url.split('|')[0]
try:
headers = dict(urlparse.parse_qsl(self.url.rsplit('|', 1)[1]))
except:
headers = dict('')
ext = os.path.splitext(urlparse.urlparse(url).path)[1][1:].lower()
hdlr = re.compile('.+? ([(]\d{4}[)]|S\d*E\d*)$').findall(self.name)
if len(hdlr) == 0: self.content = 'Uncategorised'
if ext in ['m4a', 'mp3', 'aac']: self.content = 'Music'
hdlr = re.compile('.+? (S\d*E\d*)$').findall(self.name)
if len(hdlr) > 0: self.content = 'TVShows'
hdlr = re.compile('.+? [(](\d{4})[)]$').findall(self.name)
if len(hdlr) > 0: self.content = 'Movies'
if self.content == 'Movies':
dest = os.path.join(downloadPath, self.content)
control.makeFile(dest)
dest = os.path.join(dest, sysname)
control.makeFile(dest)
elif self.content == 'TVShows':
d = re.compile('(.+?) S(\d*)E(\d*)$').findall(sysname)[0]
dest = os.path.join(downloadPath, self.content)
control.makeFile(dest)
dest = os.path.join(dest, d[0])
control.makeFile(dest)
dest = os.path.join(dest, 'Season %01d' % int(d[1]))
control.makeFile(dest)
else:
dest = os.path.join(downloadPath, self.content)
control.makeFile(dest)
if not ext in [
'mp4', 'm4a', 'mp3', 'aac', 'mkv', 'flv', 'avi', 'mpg'
]:
ext = 'mp4'
dest = os.path.join(dest, sysname + '.' + ext)
control.infoDialog(self.name + ' Is Downloading',
'Downloads Started',
self.image,
time=7000)
try:
req = urllib2.Request(url, headers=headers)
resp = urllib2.urlopen(req, timeout=30)
except Exception, e:
removeDownload(self.url)
print '%s ERROR - File Failed To Open' % (dest)
continue
try:
self.size = int(resp.headers['Content-Length'])
except:
self.size = 0
if self.size < 1:
removeDownload(self.url)
print '%s Unknown filesize - Unable to download' % (dest)
continue
try:
resumable = 'bytes' in resp.headers['Accept-Ranges'].lower()
except:
resumable = False
size = 1024 * 1024
if self.size < size: size = self.size
gb = '%.2f GB' % (float(self.size) / 1073741824)
start = time.clock()
total = 0
notify = 0
errors = 0
count = 0
resume = 0
sleep = 0
self.clear()
control.window.setProperty(property + '.status', 'downloading')
control.window.setProperty(property + '.name', str(self.name))
control.window.setProperty(property + '.image', str(self.image))
control.window.setProperty(property + '.size', str(gb))
f = control.openFile(dest, 'wb')
chunk = None
chunks = []
while True:
downloaded = total
for c in chunks:
downloaded += len(c)
percent = min(100 * downloaded / self.size, 100)
self.speed = str(
int((downloaded / 1024) /
(time.clock() - start))) + ' KB/s'
self.percent = str(percent) + '%'
control.window.setProperty(property + '.percent',
str(self.percent))
control.window.setProperty(property + '.speed',
str(self.speed))
if percent >= notify:
control.infoDialog('Downloaded %s' % self.percent,
self.name,
self.image,
time=5000)
notify += 10
chunk = None
error = False
try:
chunk = resp.read(size)
if not chunk:
if self.percent < 99:
error = True
else:
while len(chunks) > 0:
c = chunks.pop(0)
f.write(c)
del c
f.close()
print '%s download complete' % (dest)
break
except Exception, e:
print str(e)
error = True
sleep = 10
errno = 0
if hasattr(e, 'errno'):
errno = e.errno
if errno == 10035: # 'A non-blocking socket operation could not be completed immediately'
pass
if errno == 10054: #'An existing connection was forcibly closed by the remote host'
errors = 10 #force resume
sleep = 30
if errno == 11001: # 'getaddrinfo failed'
errors = 10 #force resume
sleep = 30
if chunk:
errors = 0
chunks.append(chunk)
if len(chunks) > 5:
c = chunks.pop(0)
f.write(c)
total += len(c)
del c
if error:
errors += 1
count += 1
print '%d Error(s) whilst downloading %s' % (count, dest)
control.sleep(sleep * 1000)
if (resumable and errors > 0) or errors >= 10:
if (not resumable and resume >= 50) or resume >= 500:
#Give up!
print '%s download canceled - too many error whilst downloading' % (
dest)
break
resume += 1
errors = 0
if resumable:
chunks = []
#create new response
print 'Download resumed (%d) %s' % (resume, dest)
h = headers
h['Range'] = 'bytes=%d-' % int(total)
try:
resp = urllib2.urlopen(urllib2.Request(url,
headers=h),
timeout=10)
except:
resp = None
else:
#use existing response
pass
if control.window.getProperty(property + '.status') == 'stop':
control.infoDialog('Process Complete',
'Downloads',
time=5000)
return self.clear()
def downloader():
thumb = control.addonThumb()
fanart = control.addonFanart()
status = control.window.getProperty(property + '.status')
if not downloadPath == '':
item = control.item('[COLOR FF00b8ff]Downloads[/COLOR]',
iconImage=thumb,
thumbnailImage=thumb)
item.addContextMenuItems([], replaceItems=True)
item.setProperty('fanart_image', fanart)
control.addItem(handle=int(sys.argv[1]),
url=downloadPath,
listitem=item,
isFolder=True)
if status == 'downloading':
item = control.item('[COLOR red]Stop Downloads[/COLOR]',
iconImage=thumb,
thumbnailImage=thumb)
item.addContextMenuItems([], replaceItems=True)
item.setProperty('fanart_image', fanart)
control.addItem(handle=int(sys.argv[1]),
url=sys.argv[0] + '?action=stopDownload',
listitem=item,
isFolder=True)
else:
item = control.item('[COLOR FF00b8ff]Start Downloads[/COLOR]',
iconImage=thumb,
thumbnailImage=thumb)
item.addContextMenuItems([], replaceItems=True)
item.setProperty('fanart_image', fanart)
control.addItem(handle=int(sys.argv[1]),
url=sys.argv[0] + '?action=startDownload',
listitem=item,
isFolder=True)
if status == 'downloading':
item = control.item('[COLOR gold]Download Status[/COLOR]',
iconImage=thumb,
thumbnailImage=thumb)
item.addContextMenuItems([], replaceItems=True)
item.setProperty('Fanart_Image', fanart)
control.addItem(handle=int(sys.argv[1]),
url=sys.argv[0] + '?action=statusDownload',
listitem=item,
isFolder=True)
def download():
return []
result = cache.get(download, 600000000, table='rel_dl')
for i in result:
try:
cm = []
cm.append(('Remove from Queue',
'RunPlugin(%s?action=removeDownload&url=%s)' %
(sys.argv[0], urllib.quote_plus(i['url']))))
item = control.item(i['name'],
iconImage=i['image'],
thumbnailImage=i['image'])
item.addContextMenuItems(cm, replaceItems=True)
item.setProperty('fanart_image', fanart)
item.setProperty('Video', 'true')
item.setProperty('IsPlayable', 'true')
control.addItem(handle=int(sys.argv[1]),
url=i['url'],
listitem=item)
except:
pass
control.directory(int(sys.argv[1]), cacheToDisc=True)
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
if debrid.status() == False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
try:
if not 'tvshowtitle' in data: raise Exception()
links = []
f = [
'S%02dE%02d' % (int(data['season']), int(data['episode']))
]
t = data['tvshowtitle']
q = base64.b64decode(self.search_link) + urllib.quote_plus(
'%s %s' % (t, f[0]))
q = urlparse.urljoin(self.base_link, q)
result = client.request(q)
result = json.loads(result)
except:
links = result = []
for i in result:
try:
if not cleantitle.get(t) == cleantitle.get(i['showName']):
raise Exception()
y = i['release']
y = re.compile('[\.|\(|\[|\s](\d{4}|S\d*E\d*)[\.|\)|\]|\s]'
).findall(y)[-1]
y = y.upper()
if not any(x == y for x in f): raise Exception()
quality = i['quality']
size = i['size']
size = float(size) / 1024
size = '%.2f GB' % size
if 'X265' in quality: info = '%s | HEVC' % size
else: info = size
if '1080P' in quality: quality = '1080p'
elif quality in ['720P', 'WEBDL']: quality = 'HD'
else: quality = 'SD'
url = i['links']
for x in url.keys():
links.append({
'url': url[x],
'quality': quality,
'info': info
})
except:
pass
for i in links:
try:
url = i['url']
if len(url) > 1: raise Exception()
url = url[0].encode('utf-8')
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(url.strip().lower()).netloc)[0]
if not host in hostprDict: raise Exception()
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': i['quality'],
'language': 'en',
'url': url,
'info': i['info'],
'direct': False,
'debridonly': True
})
except:
pass
try:
hostDict2 = [(i.rsplit('.', 1)[0], i) for i in hostDict]
q = ('/tv/a-z/%s',
data['tvshowtitle']) if 'tvshowtitle' in data else (
'/movies/a-z/%s', data['title'])
q = q[0] % re.sub('^THE\s+|^A\s+', '', q[1].strip().upper())[0]
url = cache.get(self.directdl_cache, 120, q)
url = [i[0] for i in url if data['imdb'] == i[1]][0]
url = urlparse.urljoin(base64.b64decode(self.b_link), url)
try:
v = urlparse.parse_qs(urlparse.urlparse(url).query)['v'][0]
except:
v = None
if v == None:
result = self.request(url)
url = re.compile('(/ip[.]php.+?>)%01dx%02d' %
(int(data['season']), int(
data['episode']))).findall(result)[0]
url = re.compile('(/ip[.]php.+?)>').findall(url)[-1]
url = urlparse.urljoin(base64.b64decode(self.b_link), url)
url = urlparse.parse_qs(urlparse.urlparse(url).query)['v'][0]
u = base64.b64decode(self.u_link) % url
r = base64.b64decode(self.r_link) % url
j = base64.b64decode(self.j_link)
p = base64.b64decode(self.p_link)
result = self.request(u, referer=r)
secret = re.compile(
'lastChild\.value="([^"]+)"(?:\s*\+\s*"([^"]+))?').findall(
result)[0]
secret = ''.join(secret)
t = re.compile('"&t=([^"]+)').findall(result)[0]
s_start = re.compile('(?:\s+|,)s\s*=(\d+)').findall(result)[0]
m_start = re.compile('(?:\s+|,)m\s*=(\d+)').findall(result)[0]
img = re.compile('<iframe[^>]*src="([^"]+)').findall(result)
img = img[0] if len(img) > 0 else '0'
img = urllib.unquote(img)
result = client.parseDOM(result,
'div',
attrs={'class': 'ripdiv'})
result = [(re.compile('<b>(.*?)</b>').findall(i), i)
for i in result]
result = [(i[0][0], i[1].split('<p>')) for i in result
if len(i[0]) > 0]
result = [[(i[0], x) for x in i[1]] for i in result]
result = sum(result, [])
except:
result = []
for i in result:
try:
quality = i[0]
if any(x in quality for x in ['1080p', '720p', 'HD']):
quality = 'HD'
else:
quality = 'SD'
host = client.parseDOM(i[1], 'a')[-1]
host = re.sub('\s|<.+?>|</.+?>|.+?#\d*:', '', host)
host = host.strip().rsplit('.', 1)[0].lower()
host = [x[1] for x in hostDict2 if host == x[0]][0]
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
s = int(s_start) + random.randint(3, 1000)
m = int(m_start) + random.randint(21, 1000)
id = client.parseDOM(i[1], 'a', ret='onclick')[-1]
id = re.compile('[(](.+?)[)]').findall(id)[0]
url = j % (id, t) + '|' + p % (id, s, m, secret, t)
url += '|%s' % urllib.urlencode({'Referer': u, 'Img': img})
url = url.encode('utf-8')
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': True
})
except:
pass
return sources
except:
return sources
