def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
if url is None: return self._sources
if debrid.status() is False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub(r'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.search.format('8', urllib.quote(query))
else:
url = self.search.format('4', urllib.quote(query))
self.hostDict = hostDict + hostprDict
headers = {'User-Agent': client.agent()}
_html = client.request(url, headers=headers)
threads = []
for i in re.findall(r'<item>(.+?)</item>', _html, re.DOTALL):
threads.append(workers.Thread(self._get_items, i))
[i.start() for i in threads]
[i.join() for i in threads]
return self._sources
except BaseException:
return self._sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
self.items = []
if url is None: return self._sources
if debrid.status() is False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.tvsearch.format(urllib.quote(query))
else:
url = self.moviesearch.format(urllib.quote(query))
self._get_items(url)
self.hostDict = hostDict + hostprDict
threads = []
for i in self.items:
threads.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads]
[i.join() for i in threads]
return self._sources
except BaseException:
return self._sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
if url is None:
return self._sources
if debrid.status() is False:
raise Exception()
self.hostDict = hostDict + hostprDict
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
# switch to client.parseDOM() to rid import
posts = dom_parser.parse_dom(r, 'div', {'class': 'eTitle'})
posts = [
dom_parser.parse_dom(i.content, 'a', req='href') for i in posts
if i
]
posts = [(i[0].attrs['href'], re.sub('<.+?>', '', i[0].content))
for i in posts if i]
posts = [[i[0], i[1]] for i in posts]
threads = []
for i in posts:
threads.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads]
[i.join() for i in threads]
alive = [x for x in threads if x.is_alive() is True]
while alive:
alive = [x for x in threads if x.is_alive() is True]
time.sleep(0.1)
return self._sources
except:
source_utils.scraper_error('ONLINESERIES')
return self._sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
self.items = []
if url is None:
return self._sources
if debrid.status() is False:
return self._sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
urls = []
if 'tvshowtitle' in data:
url = self.search2.format(urllib.quote(query))
else:
url = self.search.format(urllib.quote(query))
url = urlparse.urljoin(self.base_link, url)
urls.append(url)
url2 = url + '/2/'
urls.append(url2)
# log_utils.log('urls = %s' % urls, log_utils.LOGDEBUG)
threads = []
for url in urls:
threads.append(workers.Thread(self._get_items, url))
[i.start() for i in threads]
[i.join() for i in threads]
threads2 = []
for i in self.items:
threads2.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads2]
[i.join() for i in threads2]
return self._sources
except:
source_utils.scraper_error('KICKASS2')
return self._sources
def movie(self, imdb, title, localtitle, aliases, year):
if debrid.status(True) is False:
return
try:
url = {'imdb': imdb, 'title': title, 'year': year}
url = urllib.urlencode(url)
return url
except Exception:
return
def sources(self, url, hostDict, hostprDict):
try:
self.sources = []
if url is None:
return self.sources
if debrid.status() is False:
raise Exception()
self.hostDict = hostDict + hostprDict
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']
# title = title.replace('&', 'and').replace('Special Victims Unit', 'SVU')
hdlr = data['year']
hdlr2 = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else ''
imdb = data['imdb']
url = self.search(title, hdlr)
headers = {'User-Agent': client.agent()}
r = self.scraper.get(url, headers=headers).content
if hdlr2 == '':
r = dom_parser.parse_dom(r, 'ul', {'id': 'releases'})[0]
else:
r = dom_parser.parse_dom(r, 'ul', {'id': 'episodes'})[0]
r = dom_parser.parse_dom(r.content, 'a', req=['href'])
r = [(i.content, urlparse.urljoin(self.base_link, i.attrs['href']))
for i in r if i and i.content != 'Watch']
if hdlr2 != '':
r = [(i[0], i[1]) for i in r if hdlr2.lower() in i[0].lower()]
threads = []
for i in r:
threads.append(workers.Thread(self._get_sources, i[0], i[1]))
[i.start() for i in threads]
# [i.join() for i in threads]
alive = [x for x in threads if x.is_alive() is True]
while alive:
alive = [x for x in threads if x.is_alive() is True]
time.sleep(0.1)
return self.sources
except:
source_utils.scraper_error('RAPIDMOVIEZ')
return self.sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data['title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s s%02de%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
try:
posts = client.parseDOM(r, 'div', attrs={'class': 'box-info'})
for post in posts:
data = client.parseDOM(post, 'a', ret='href')
u = [i for i in data if '/torrent/' in i]
for u in u:
match = '%s %s' % (title, hdlr)
match = match.replace('+', '-').replace(' ', '-').replace(':-', '-').replace('---', '-')
if not match in u: continue
u = self.base_link + u
r = client.request(u)
r = client.parseDOM(r, 'div', attrs={'class': 'torrent-category-detail clearfix'})
for t in r:
link = re.findall('href="magnet:(.+?)" onclick=".+?"', t)[0]
link = 'magnet:%s' % link
link = str(client.replaceHTMLCodes(link).split('&tr')[0])
seeds = int(re.compile('<span class="seeds">(.+?)</span>').findall(t)[0])
if self.min_seeders > seeds:
continue
quality, info = source_utils.get_release_quality(link, link)
try:
size = re.findall('<strong>Total size</strong> <span>(.+?)</span>', t)
for size in size:
size = '%s' % size
info.append(size)
except BaseException:
pass
info = ' | '.join(info)
sources.append(
{'source': 'Torrent', 'quality': quality, 'language': 'en', 'url': link, 'info': info,
'direct': False, 'debridonly': True})
except:
return
return sources
except:
return sources
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
if debrid.status() is False:
return
try:
url = {'imdb': imdb, 'tvdb': tvdb, 'tvshowtitle': tvshowtitle, 'year': year}
url = urllib.urlencode(url)
return url
except Exception:
failure = traceback.format_exc()
log_utils.log('TPB - Exception: \n' + str(failure))
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None: return sources
if debrid.status() is False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
query = '%s %s' % (data['title'], data['year'])
url = self.search_link % urllib.quote(query)
url = urlparse.urljoin(self.base_link, url).replace('%20', '-')
html = client.request(url)
try:
results = client.parseDOM(html, 'div', attrs={'class': 'ava1'})
except:
failure = traceback.format_exc()
log_utils.log('YIFYDLL - Exception: \n' + str(failure))
return sources
for torrent in results:
link = re.findall(
'a data-torrent-id=".+?" href="(magnet:.+?)" class=".+?" title="(.+?)"',
torrent, re.DOTALL)
for link, name in link:
link = str(client.replaceHTMLCodes(link).split('&tr')[0])
quality, info = source_utils.get_release_quality(
name, name)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
torrent)[-1]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except Exception:
pass
info = ' | '.join(info)
sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': link,
'info': info,
'direct': False,
'debridonly': True
})
return sources
except:
failure = traceback.format_exc()
log_utils.log('YIFYDLL - Exception: \n' + str(failure))
return
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
if url is None: return self._sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data[
'title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
query = self.search_link % cleantitle.geturl(query)
url = urlparse.urljoin(self.base_link, query)
r = client.request(url)
posts = dom_parser2.parse_dom(r, 'div', {'class': 'eTitle'})
posts = [
dom_parser2.parse_dom(i.content, 'a', req='href')
for i in posts if i
]
posts = [(i[0].attrs['href'], re.sub('<.+?>', '', i[0].content))
for i in posts if i]
posts = [
(i[0], i[1]) for i in posts
if (cleantitle.get_simple(i[1].split(hdlr)[0]) ==
cleantitle.get(title) and hdlr.lower() in i[1].lower())
]
self.hostDict = hostDict + hostprDict
threads = []
for i in posts:
threads.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads]
[i.join() for i in threads]
alive = [x for x in threads if x.is_alive() == True]
while alive:
alive = [x for x in threads if x.is_alive() == True]
time.sleep(0.1)
return self._sources
except Exception:
return self._sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
if debrid.status() is False:
raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.tvsearch.format(urllib.quote_plus(query))
url = urlparse.urljoin(self.base_link, url)
else:
url = self.moviesearch.format(urllib.quote_plus(query))
url = urlparse.urljoin(self.base_link, url)
items = self._get_items(url)
hostDict = hostDict + hostprDict
for item in items:
try:
name = item[0]
quality, info = source_utils.get_release_quality(
name, name)
info.append(item[2])
info = ' | '.join(info)
url = item[1]
url = url.split('&tr')[0]
sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except BaseException:
pass
return sources
except BaseException:
return sources
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])
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode'])) \
if 'tvshowtitle' in data else '%s' % (data['title'])
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url).replace('-', '+')
r = self.scraper.get(url).content
posts = client.parseDOM(r, "div", attrs={"class": "postpage_movie_download"})
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')
for i in u:
items.append(i)
except:
pass
seen_urls = set()
for item in items:
try:
i = str(item)
r = client.request(i)
u = client.parseDOM(r, "div", attrs={"class": "multilink_lnks"})
for t in u:
r = client.parseDOM(t, 'a', ret='href')
for url in r:
if 'www.share-online.biz' in url:
continue
if url in seen_urls:
continue
seen_urls.add(url)
quality, info = source_utils.get_release_quality(url)
if 'SD' in quality:
continue
valid, host = source_utils.is_host_valid(url, hostDict)
sources.append(
{'source': host, 'quality': quality, 'language': 'en', 'url': url, 'info': info,
'direct': False, 'debridonly': True})
except:
pass
return sources
except:
return
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
if debrid.status() is False:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
q = '%s' % cleantitle.get_gan_url(data['title'])
url = self.base_link + self.search_link % q
r = self.scraper.get(url).content
v = re.compile(
'<a href="(.+?)" class="ml-mask jt" title="(.+?)">\r\n\t\t\t\t\t\t\t\t\t\t\t\t<span class=".+?">(.+?)</span>').findall(
r)
for url, check, quality in v:
t = '%s (%s)' % (data['title'], data['year'])
if t not in check:
raise Exception()
key = url.split('-hd')[1]
r = self.scraper.get('https://ganool.ws/moviedownload.php?q=' + key).content
r = re.compile('<a rel=".+?" href="(.+?)" target=".+?">').findall(r)
for url in r:
if any(x in url for x in ['.rar']):
continue
quality = source_utils.check_url(quality)
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
continue
sources.append({'source': host, 'quality': quality, 'language': 'en', 'url': url, 'direct': False,
'debridonly': True})
return sources
except:
return sources
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
if debrid.status(True) is False:
return
try:
if url is None:
return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['title'], url['premiered'], url['season'], url[
'episode'] = title, premiered, season, episode
url = urllib.urlencode(url)
return url
except Exception:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
if debrid.status() is False:
return
try:
if url is None:
return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['title'], url['premiered'], url['season'], url['episode'] = title, premiered, season, episode
url = urllib.urlencode(url)
return url
except Exception:
failure = traceback.format_exc()
log_utils.log('TPB - Exception: \n' + str(failure))
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
if debrid.status() is False: raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else '%s' % \
data[
'imdb']
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
token = client.request(self.token)
token = json.loads(token)["token"]
if 'tvshowtitle' in data:
search_link = self.tvsearch.format(token,
urllib.quote_plus(query),
'format=json_extended')
else:
search_link = self.msearch.format(token, data['imdb'],
'format=json_extended')
rjson = client.request(search_link)
files = json.loads(rjson)['torrent_results']
for file in files:
name = file["title"]
quality, info = source_utils.get_release_quality(name, name)
size = source_utils.convert_size(file["size"])
info.append(size)
info = ' | '.join(info)
url = file["download"]
url = url.split('&tr')[0]
sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
return sources
except BaseException:
return sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
if url is None:
return self._sources
if debrid.status() is False:
return self._sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
self.title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace('Special Victims Unit', 'SVU')
self.hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
if 'tvshowtitle' in data:
url = self.search.format('8', urllib.quote(query))
else:
url = self.search.format('4', urllib.quote(query))
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
headers = {'User-Agent': client.agent()}
_html = client.request(url, headers=headers)
threads = []
for i in re.findall(r'<item>(.+?)</item>', _html, re.DOTALL):
threads.append(workers.Thread(self._get_items, i))
[i.start() for i in threads]
[i.join() for i in threads]
return self._sources
except:
source_utils.scraper_error('TORRENTDOWNLOADS')
return self._sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data['title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s s%02de%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub(r'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
try:
posts = client.parseDOM(r, 'tbody', attrs={'id': 'results'})
for post in posts:
link = re.findall('a href="(magnet:.+?)" title="(.+?)"', post, re.DOTALL)
for url, data in link:
if not hdlr in data: continue
url = url.split('&tr')[0]
quality, info = source_utils.get_release_quality(data)
if any(
x in url for x in
['FRENCH', 'Ita', 'italian', 'TRUEFRENCH', '-lat-', 'Dublado']): continue
info = ' | '.join(info)
sources.append(
{'source': 'Torrent', 'quality': quality, 'language': 'en', 'url': url, 'info': info,
'direct': False, 'debridonly': True})
except:
return
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
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']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s %s' % (title, hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url).replace('%3A+', '+')
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
if r is None and 'tvshowtitle' in data:
season = re.search('S(.*?)E', hdlr)
season = season.group(1)
url = title
r = client.request(url)
for loopCount in range(0, 2):
if loopCount == 1 or (r is None and 'tvshowtitle' in data):
r = client.request(url)
posts = client.parseDOM(r, "h2", attrs={"class": "postTitle"})
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')
for i in u:
name = str(i)
items.append(name)
tit = name.rsplit('/', 1)[0]
tit = tit.rsplit('/', 1)[1].upper()
t = tit.split(hdlr)[0].replace(
data['year'], '').replace('(', '').replace(
')', '').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(title):
continue
except:
source_utils.scraper_error('MAXRLS')
pass
if len(items) > 0:
break
for item in items:
try:
i = str(item)
r = client.request(i)
u = client.parseDOM(r,
"div",
attrs={"class": "postContent"})
for t in u:
r = client.parseDOM(t, 'a', ret='href')
for url in r:
quality, info = source_utils.get_release_quality(
url)
valid, host = source_utils.is_host_valid(
url, hostDict)
if not valid:
continue
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('MAXRLS')
pass
return sources
except:
source_utils.scraper_error('MAXRLS')
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
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']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s %s' % (title, hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote(query)
url = urlparse.urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
html = client.request(url)
html = html.replace(' ', ' ')
try:
results = client.parseDOM(html,
'table',
attrs={'id': 'searchResult'})
except:
return sources
url2 = url.replace('/1/', '/2/')
html2 = client.request(url2)
html2 = html2.replace(' ', ' ')
try:
results += client.parseDOM(html2,
'table',
attrs={'id': 'searchResult'})
except:
return sources
results = ''.join(results)
rows = re.findall('<tr(.+?)</tr>', results, re.DOTALL)
if rows is None:
return sources
for entry in rows:
try:
try:
url = 'magnet:%s' % (re.findall(
'a href="magnet:(.+?)"', entry, re.DOTALL)[0])
url = str(client.replaceHTMLCodes(url).split('&tr')[0])
except:
continue
if any(x in url.lower() for x in [
'french', 'italian', 'spanish', 'truefrench',
'dublado', 'dubbed'
]):
continue
try:
name = re.findall(
'class="detLink" title=".+?">(.+?)</a>', entry,
re.DOTALL)[0]
name = client.replaceHTMLCodes(name)
t = name.split(hdlr)[0].replace(
data['year'],
'').replace('(',
'').replace(')',
'').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(title):
continue
except:
continue
if hdlr not in name:
continue
try:
seeders = int(
re.findall('<td align="right">(.+?)</td>', entry,
re.DOTALL)[0])
except:
continue
if self.min_seeders > seeders:
continue
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
entry)[-1]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
sources.append({
'source': 'torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('PIRATEBAY')
continue
return sources
except:
source_utils.scraper_error('PIRATEBAY')
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
hostDict = hostprDict + hostDict
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']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s %s' % (title, hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url).replace('-', '+')
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
# r = self.scraper.get(url).content
if r is None and 'tvshowtitle' in data:
season = re.search('S(.*?)E', hdlr)
season = season.group(1)
url = title
# r = self.scraper.get(url).content
r = client.request(url)
for loopCount in range(0, 2):
if loopCount == 1 or (r is None and 'tvshowtitle' in data):
r = self.scraper.get(url).content
# r = client.request(url)
posts = client.parseDOM(
r, "div", attrs={"class": "postpage_movie_download"})
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')
for i in u:
name = str(i)
items.append(name)
except:
pass
if len(items) > 0:
break
for item in items:
try:
i = str(item)
# r = self.scraper.get(i).content
r = client.request(i)
if r is None:
continue
tit = client.parseDOM(r,
'meta',
attrs={'property': 'og:title'},
ret='content')[0]
t = tit.split(hdlr)[0].replace(data['year'], '').replace(
'(', '').replace(')', '').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(title):
continue
if hdlr not in tit:
continue
u = client.parseDOM(r,
"div",
attrs={"class": "multilink_lnks"})
for t in u:
r = client.parseDOM(t, 'a', ret='href')
for url in r:
if 'www.share-online.biz' in url:
continue
if url in str(sources):
continue
quality, info = source_utils.get_release_quality(
url, url)
valid, host = source_utils.is_host_valid(
url, hostDict)
if valid:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('2DDL')
pass
return sources
except:
source_utils.scraper_error('2DDL')
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
hostDict = hostprDict + hostDict
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['title'].replace('&', 'and')
year = data['year']
query = '%s %s' % (title, year)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = urlparse.urljoin(self.base_link, self.post_link)
post = 'do=search&subaction=search&search_start=0&full_search=0&result_from=1&story=%s' % urllib.quote_plus(
query)
r = client.request(url, post=post)
# log_utils.log('r = %s' % r, log_utils.LOGDEBUG)
r = client.parseDOM(r, 'div', attrs={'class': 'box-out margin'})
# log_utils.log('r = %s' % r, log_utils.LOGDEBUG)
# switch to client.parseDOM() to rid import
r = [(dom_parser.parse_dom(i, 'div', attrs={'class':
'news-title'}))
for i in r if data['imdb'] in i]
r = [(dom_parser.parse_dom(i[0], 'a', req='href')) for i in r if i]
r = [(i[0].attrs['href'], i[0].content) for i in r if i]
for item in r:
try:
name = item[0]
s = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))',
name)
s = s[0] if s else '0'
data = client.request(item[0])
data = dom_parser.parse_dom(data,
'div',
attrs={'id': 'r-content'})
data = re.findall('\s*<b><a href="(.+?)".+?</a></b>',
data[0].content, re.DOTALL)
for url in data:
try:
try:
qual = client.request(url)
quals = re.findall(
'span class="file-title" id="file-title">(.+?)</span',
qual)
if quals == []:
raise Exception()
for q in quals:
quality, info = source_utils.get_release_quality(
q, url)
except:
quality = 'SD'
info = []
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
if not 'turbobit' in url:
continue
if url in str(sources):
continue
sources.append({
'source': 'turbobit',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': True,
'debridonly': True
})
# log_utils.log('sources = %s' % sources, log_utils.LOGDEBUG)
except:
source_utils.scraper_error('ULTRAHDINDIR')
pass
except:
source_utils.scraper_error('ULTRAHDINDIR')
pass
# log_utils.log('sources = %s' % sources, log_utils.LOGDEBUG)
return sources
except:
source_utils.scraper_error('ULTRAHDINDIR')
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
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']
title = title.replace('&', 'and').replace('Special Victims Unit', 'SVU')
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s %s' % (title, hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = urlparse.urljoin(self.base_link, self.search_link.format(query[0].lower(), cleantitle.geturl(query)))
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
if '<tbody' not in r:
return sources
r = client.parseDOM(r, 'tbody')[0]
results = client.parseDOM(r, 'tr')
posts = [i for i in results if 'magnet:' in i]
try:
next_page = [i for i in results if 'Next Page' in i]
if next_page == []:
raise Exception()
page = client.parseDOM(next_page, 'a', ret='href', attrs={'title': 'Downloads | Page 2'})[0]
r2 = client.request(self.base_link+page)
results2 = client.parseDOM(r2, 'tr')
posts += [i for i in results2 if 'magnet:' in i]
except:
pass
for post in posts:
post = post.replace(' ', ' ')
links = client.parseDOM(post, 'a', ret='href')
magnet = [i.replace('&', '&') for i in links if 'magnet:' in i][0]
url = magnet.split('&tr')[0]
if any(x in url.lower() for x in ['french', 'italian', 'spanish', 'truefrench', 'dublado', 'dubbed']):
continue
name = client.parseDOM(post, 'a', ret='title')[1]
t = name.split(hdlr)[0].replace(data['year'], '').replace('(', '').replace(')', '').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(title):
continue
if hdlr not in name:
continue
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall('((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))', post)[0]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size.replace(',', '.'))) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
sources.append({'source': 'torrent', 'quality': quality, 'language': 'en', 'url': url,
'info': info, 'direct': False, 'debridonly': True})
return sources
except:
source_utils.scraper_error('MAGNETDL')
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None: return sources
if debrid.status() is 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 = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '',
data['tvshowtitle'])
t = t.replace("&", "")
q = self.search_link + urllib.quote_plus('%s %s' % (t, f[0]))
q = urlparse.urljoin(self.base_link, q)
result = client.request(q)
print(q)
result = json.loads(result)
result = result['results']
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']
quality = quality.upper()
size = i['size']
size = float(size) / 1024
size = '%.2f GB' % size
if any(x in quality for x in ['HEVC', 'X265', 'H265']):
info = '%s | HEVC' % size
else:
info = size
if '1080P' in quality:
quality = '1080p'
elif '720P' in quality:
quality = 'HD'
else:
quality = 'SD'
url = i['links']
# for x in url.keys(): links.append({'url': url[x], 'quality': quality, 'info': info})
links = []
for x in url.keys():
links.append({'url': url[x], 'quality': quality})
for link in links:
try:
url = link['url']
quality2 = link['quality']
# url = url[1]
# url = link
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': quality2,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
if debrid.status() is False:
raise Exception()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
post = {'query': data['imdb']}
url = urlparse.urljoin(self.base_link, 'engine/ajax/search.php')
r = self.scraper.post(url, data=post).content
urls = client.parseDOM(r, 'a', ret='href')
urls = [i for i in urls if not data['imdb'] in i]
hostDict = hostprDict + hostDict
links = []
for u in urls:
try:
data = self.scraper.get(u).content
data = re.findall('</iframe>(.+?)QuoteEEnd--><br /><br',
data, re.DOTALL)[0]
links += re.findall(
'''start--><b>(.+?)</b>.+?<b><a href=['"](.+?)['"]''',
data, re.DOTALL)
except Exception:
pass
links = [(i[0], i[1]) for i in links if not 'vip' in i[0].lower()]
for name, url in links:
try:
name = re.sub('<.+?>', '', name)
if '4K' in name:
quality = '4K'
elif '1080p' in name:
quality = '1080p'
elif '720p' in name:
quality = '720p'
else:
quality = 'SD'
info = []
if '3D' in name or '.3D.' in url:
info.append('3D')
quality = '1080p'
if any(i in ['hevc', 'h265', 'x265'] for i in name):
info.append('HEVC')
info = ' | '.join(info)
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
if any(x in url for x in ['.rar', '.zip', '.iso', 'turk']):
raise Exception()
if 'ftp' in url:
host = 'CDN'
direct = True
else:
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid: raise Exception()
host = host
direct = False
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': direct,
'debridonly': True
})
except Exception:
pass
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data[
'title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (data['tvshowtitle'], int(data['season']), int(data['episode'])) if \
'tvshowtitle' in data else '%s' % (data['title'])
url = self.search_link % urllib.quote_plus(query).lower()
url = urlparse.urljoin(self.base_link, url)
headers = {'Referer': url}
r = self.scraper.get(url, headers=headers).content
items = dom_parser2.parse_dom(r, 'h2')
items = [
dom_parser2.parse_dom(i.content,
'a',
req=['href', 'rel', 'data-wpel-link'])
for i in items
]
items = [(i[0].content, i[0].attrs['href']) for i in items]
hostDict = hostprDict + hostDict
for item in items:
try:
name = item[0]
name = client.replaceHTMLCodes(name)
query = query.lower().replace(' ', '-')
if not query in item[1]:
continue
url = item[1]
headers = {'Referer': url}
r = self.scraper.get(url, headers=headers).content
links = dom_parser2.parse_dom(
r, 'a', req=['href', 'rel', 'data-wpel-link'])
links = [i.attrs['href'] for i in links]
for url in links:
try:
if hdlr in name.upper() and cleantitle.get(
title) in cleantitle.get(name):
fmt = re.sub(
'(.+)(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*)(\.|\)|\]|\s)',
'', name.upper())
fmt = re.split('\.|\(|\)|\[|\]|\s|\-', fmt)
fmt = [i.lower() for i in fmt]
if any(
i.endswith(('subs', 'sub', 'dubbed',
'dub')) for i in fmt):
raise Exception()
if any(i in ['extras'] for i in fmt):
raise Exception()
quality, info = source_utils.get_release_quality(
name, url)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+) (?:GB|GiB|MB|MiB))',
name[2])[-1]
div = 1 if size.endswith(
('GB', 'GiB')) else 1024
size = float(
re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
if not any(x in url
for x in ['.rar', '.zip', '.iso']):
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
host = \
re.findall('([\w]+[.][\w]+)$', urlparse.urlparse(url.strip().lower()).netloc)[0]
if host in hostDict:
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
except:
pass
check = [i for i in sources if not i['quality'] == 'CAM']
if check:
sources = check
return sources
except:
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'] if 'tvshowtitle' in data else data[
'title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode'])) \
if 'tvshowtitle' in data else '%s %s' % (data['title'], data['year'])
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url).replace('-', '+')
r = self.scraper.get(url).content
if r == None and 'tvshowtitle' in data:
season = re.search('S(.*?)E', hdlr)
season = season.group(1)
url = title
r = self.scraper.get(url).content
for loopCount in range(0, 2):
if loopCount == 1 or (r == None and 'tvshowtitle' in data):
r = self.scraper.get(url).content
posts = client.parseDOM(r,
"table",
attrs={"class": "download"})
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')
for i in u:
try:
name = str(i)
items.append(name)
except:
pass
except:
pass
if len(items) > 0: break
for item in items:
try:
info = []
i = str(item)
i = self.base_link + i
r = self.scraper.get(i).content
u = client.parseDOM(r, "div", attrs={"class": "dl-links"})
for t in u:
r = re.compile(
'a href=".+?" rel=".+?">(.+?)<').findall(t)
for url in r:
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
quality, info = source_utils.get_release_quality(
url)
valid, host = source_utils.is_host_valid(
url, hostDict)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
check = [i for i in sources if not i['quality'] == 'CAM']
if check: sources = check
return sources
except:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None: return sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data['title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
category = '+category%3ATV' if 'tvshowtitle' in data else '+category%3AMovies'
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|<|>|\|)', ' ', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url) + str(category)
html = client.request(url)
html = html.replace(' ', ' ')
try:
results = \
client.parseDOM(html, 'table', attrs={'class': 'table table-condensed table-torrents vmiddle'})[0]
except Exception:
return sources
rows = re.findall('<tr(.+?)</tr>', results, re.DOTALL)
if rows is None:
return sources
for entry in rows:
try:
try:
name = re.findall('<a class=".+?>(.+?)</a>', entry, re.DOTALL)[0]
name = client.replaceHTMLCodes(name).replace('<hl>', '').replace('</hl>', '')
if not cleantitle.get(title) in cleantitle.get(name):
continue
except Exception:
continue
y = re.findall('[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]', name)[-1].upper()
if not y == hdlr:
continue
try:
seeders = int(
re.findall('class="progress prog trans90" title="Seeders: (.+?) \|', entry, re.DOTALL)[0])
except Exception:
continue
if self.min_seeders > seeders:
continue
try:
link = 'magnet:%s' % (re.findall('href="magnet:(.+?)"', entry, re.DOTALL)[0])
link = str(client.replaceHTMLCodes(link).split('&tr')[0])
except Exception:
continue
quality, info = source_utils.get_release_quality(name, name)
try:
size = re.findall('((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))', entry)[-1]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except Exception:
pass
info = ' | '.join(info)
sources.append(
{'source': 'Torrent', 'quality': quality, 'language': 'en', 'url': link, 'info': info,
'direct': False, 'debridonly': True})
except Exception:
continue
check = [i for i in sources if not i['quality'] == 'CAM']
if check:
sources = check
return sources
except Exception:
return self._sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is 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'] if 'tvshowtitle' in data else data[
'title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
html = self.scraper.get(url).content
posts = client.parseDOM(html, 'item')
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
t = client.parseDOM(post, 'title')[0]
u = client.parseDOM(post, 'enclosure', ret='url')
s = re.search(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
post)
s = s.groups()[0] if s else '0'
items += [(t, i, s) for i in u]
except:
pass
for item in items:
try:
url = item[1]
if any(x in url
for x in ['.rar', '.zip', '.iso', '.part']):
raise Exception()
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
name = item[0]
name = client.replaceHTMLCodes(name)
t = re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*|3D)(\.|\)|\]|\s|)(.+|)',
'',
name,
flags=re.I)
if not cleantitle.get(t) == cleantitle.get(title):
raise Exception()
y = re.findall(
'[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]',
name)[-1].upper()
if not y == hdlr:
raise Exception()
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
item[2])[-1]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
check = [i for i in sources if not i['quality'] == 'CAM']
if check:
sources = check
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is 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'] if 'tvshowtitle' in data else data[
'title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else '%s' % (data['imdb'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
s = self.scraper.get(self.base_link).content
s = re.findall('\'(http.+?)\'', s) + re.findall('\"(http.+?)\"', s)
s = [
i for i in s if urlparse.urlparse(self.base_link).netloc in i
and len(i.strip('/').split('/')) > 3
]
s = s[0] if s else urlparse.urljoin(self.base_link, 'vv')
s = s.strip('/')
url = s + self.search_link % urllib.quote_plus(query)
r = self.scraper.get(url).content
r = client.parseDOM(r, 'h2')
l = zip(client.parseDOM(r, 'a', ret='href'),
client.parseDOM(r, 'a', ret='title'))
r = [(i[0], i[1],
re.sub('(\.|\(|\[|\s)(\d{4}|3D)(\.|\)|\]|\s|)(.+|)', '',
i[1]),
re.findall('[\.|\(|\[|\s](\d{4}|)([\.|\)|\]|\s|].+)', i[1]))
for i in l]
r = [(i[0], i[1], i[2], i[3][0][0], i[3][0][1]) for i in r if i[3]]
r = [(i[0], i[1], i[2], i[3], re.split('\.|\(|\)|\[|\]|\s|\-',
i[4])) for i in r]
r = [
i for i in r if cleantitle.get(title) == cleantitle.get(i[2])
and data['year'] == i[3]
]
r = [
i for i in r if not any(x in i[4] for x in [
'HDCAM', 'CAM', 'DVDR', 'DVDRip', 'DVDSCR', 'HDTS', 'TS',
'3D'
])
]
r = [i for i in r if '1080p' in i[4]
][:1] + [i for i in r if '720p' in i[4]][:1]
if 'tvshowtitle' in data:
posts = [(i[1], i[0]) for i in l]
else:
posts = [(i[1], i[0]) for i in l]
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
t = post[0]
u = self.scraper.get(post[1]).content
u = re.findall('"(http.+?)"', u) + re.findall(
'"(http.+?)"', u)
u = [i for i in u if not '/embed/' in i]
u = [i for i in u if not 'youtube' in i]
items += [(t, i) for i in u]
except:
pass
seen_urls = set()
for item in items:
try:
name = item[0]
name = client.replaceHTMLCodes(name)
t = re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*|3D)(\.|\)|\]|\s|)(.+|)',
'', name)
if not cleantitle.get(t) == cleantitle.get(title):
raise Exception()
y = re.findall(
'[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]',
name)[-1].upper()
if not y == hdlr:
raise Exception()
url = item[1]
if url in seen_urls:
continue
seen_urls.add(url)
quality, info = source_utils.get_release_quality(url, name)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+) (?:GB|GiB|MB|MiB))',
item[2])[-1]
div = 1 if size.endswith(('GB', 'GiB')) else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size)) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(url.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': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
check = [i for i in sources if not i['quality'] == 'CAM']
if check:
sources = check
return sources
except:
return
