def sources(self, url, hostDict, hostprDict):
try:
hostDict = hostDict + hostprDict
sources = []
r = self.scraper.get(url).content
u = client.parseDOM(r, "div", attrs={"class": "ml-item"})
for i in u:
t = re.compile('<a href="(.+?)"').findall(i)
for r in t:
t = self.scraper.get(r).content
results1 = re.compile('<a href="(.+?)" class="lnk').findall(t)
for url in results1:
if self.base_link in url:
continue
quality, info = source_utils.get_release_quality(url, 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': False})
results2 = re.compile('<iframe src="(.+?)"').findall(t)
for link in results2:
if "gomostream.com" in link:
for source in more_sources.more_gomo(link, hostDict):
sources.append(source)
else:
if "//ouo.io/" in link:
continue
quality, info = source_utils.get_release_quality(link, link)
valid, host = source_utils.is_host_valid(link, hostDict)
sources.append(
{'source': host, 'quality': quality, 'language': 'en', 'url': link, 'info': info,
'direct': False, 'debridonly': False})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
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']
url = urlparse.urljoin(self.base_link, self.search_link % urllib.quote_plus(cleantitle.query(title)))
if 'tvshowtitle' in data:
html = self.scraper.get(url).content
match = re.compile('class="post-item.+?href="(.+?)" title="(.+?)"', re.DOTALL).findall(html)
for url, item_name in match:
if cleantitle.getsearch(title).lower() in cleantitle.getsearch(item_name).lower():
season_url = '%02d' % int(data['season'])
episode_url = '%02d' % int(data['episode'])
sea_epi = 'S%sE%s' % (season_url, episode_url)
result = self.scraper.get(url).content
regex = re.compile('href="(.+?)"', re.DOTALL).findall(result)
for ep_url in regex:
if sea_epi in ep_url:
quality, info = source_utils.get_release_quality(url)
sources.append({'source': 'CDN', 'quality': quality, 'language': 'en',
'url': ep_url, 'direct': False, 'debridonly': False})
else:
html = self.scraper.get(url).content
match = re.compile('<div class="thumbnail".+?href="(.+?)" title="(.+?)"', re.DOTALL).findall(html)
for url, item_name in match:
if cleantitle.getsearch(title).lower() in cleantitle.getsearch(item_name).lower():
quality, info = source_utils.get_release_quality(url)
result = self.scraper.get(url).content
regex = re.compile('href="/download.php.+?link=(.+?)"', re.DOTALL).findall(result)
for link in regex:
if 'server=' not in link:
try:
link = base64.b64decode(link)
except Exception:
pass
try:
host = link.split('//')[1].replace('www.', '')
host = host.split('/')[0].lower()
except Exception:
pass
if not self.filter_host(host):
continue
sources.append({'source': host, 'quality': quality, 'language': 'en',
'url': link, 'direct': False, 'debridonly': False})
return sources
except Exception:
failure = traceback.format_exc()
log_utils.log('ExtraMovie - Exception: \n' + str(failure))
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
hostDict = hostDict + hostprDict
r = self.scraper.get(url).content
match = re.compile(
'<a href="http://www.tvmovieflix.com/report-.+?/(.+?)" target="_blank"><span class="a">Report Broken</span></a></li>',
re.DOTALL | re.M).findall(r)
for link in match:
if "/show/" in url:
surl = "http://www.tvmovieflix.com/e/" + link
else:
surl = "http://www.tvmovieflix.com/m/" + link
i = self.scraper.get(surl).content
match = re.compile('<IFRAME.+?SRC="(.+?)"',
re.DOTALL | re.IGNORECASE).findall(i)
for link in match:
if "realtalksociety.com" in link:
r = requests.get(link).content
match = re.compile(
'<source src="(.+?)" type="video/mp4">',
re.DOTALL | re.IGNORECASE).findall(r)
for url in match:
valid, host = source_utils.is_host_valid(
url, hostDict)
quality, info = source_utils.get_release_quality(
url, url)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': url,
'direct': True,
'debridonly': False
})
else:
valid, host = source_utils.is_host_valid(
link, hostDict)
quality, info = source_utils.get_release_quality(
link, link)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': link,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
urls = self.search(data['title'], data['year'])
for url in urls:
try:
link = client.replaceHTMLCodes(url[1])
link = link.encode('utf-8')
if link in sources: continue
if 'snahp' in link:
data = client.request(link)
data = client.parseDOM(data, 'center')
data = [i for i in data if 'Hidden Link' in i][0]
link = client.parseDOM(data, 'a', ret='href')[0]
if 'google' in link:
quality, info2 = source_utils.get_release_quality(
url[0], link)
sources.append({
'source': 'gvideo',
'quality': quality,
'language': 'en',
'url': link,
'direct': False,
'debridonly': False
})
else:
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(link.strip().lower()).netloc)[0]
if host in hostDict:
host = host.encode('utf-8')
quality, info2 = source_utils.get_release_quality(
url[0], link)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': link,
'direct': False,
'debridonly': False
})
except BaseException:
pass
return sources
except BaseException:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
aliases = eval(data['aliases'])
if 'tvshowtitle' in data:
ep = data['episode']
url = '%s/film/%s-season-%01d/watching.html?ep=%s' % (
self.base_link, cleantitle.geturl(data['tvshowtitle']), int(data['season']), ep)
r = client.request(url, timeout='10', output='geturl')
if url is None:
url = self.searchShow(data['tvshowtitle'], data['season'], aliases)
else:
url = self.searchMovie(data['title'], data['year'], aliases)
if url is None:
url = '%s/film/%s/watching.html?ep=0' % (self.base_link, cleantitle.geturl(data['title']))
if url is None:
raise Exception()
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:
link = "https:" + link if not link.startswith('http') else link
if 'vidcloud' in link:
r = client.request(link, timeout='10')
match = getSum.findSum(r)
for url in match:
url = "https:" + url if not url.startswith('http') else url
url = requests.get(url).url if 'api.vidnode' in url else url
valid, host = source_utils.is_host_valid(url, hostDict)
if valid:
quality, info = source_utils.get_release_quality(url, url)
sources.append(
{'source': host, 'quality': quality, 'language': 'en', 'info': info, 'url': url,
'direct': False, 'debridonly': False})
else:
valid, host = source_utils.is_host_valid(link, hostDict)
if valid:
quality, info = source_utils.get_release_quality(link, link)
sources.append({'source': host, 'quality': quality, 'language': 'en', 'info': info, 'url': link,
'direct': False, 'debridonly': False})
return sources
except:
return sources
def _get_sources(self, item, hostDict):
try:
quality, info = source_utils.get_release_quality(item[0], item[1])
size = item[2] if item[2] != '0' else item[0]
try:
size = re.findall('((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))', size)[-1]
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 Exception:
pass
data = self.scraper.get(item[1]).content
try:
r = client.parseDOM(data, 'li', attrs={'class': 'elemento'})
r = [(dom_parser2.parse_dom(i, 'a', req='href')[0],
dom_parser2.parse_dom(i, 'img', req='alt')[0],
dom_parser2.parse_dom(i, 'span', {'class': 'd'})[0]) for i in r]
urls = [('http:' + i[0].attrs['href'] if not i[0].attrs['href'].startswith('http') else
i[0].attrs['href'], i[1].attrs['alt'], i[2].content) for i in r if i[0] and i[1]]
for url, host, qual in urls:
try:
if any(x in url for x in ['.rar', '.zip', '.iso', ':Upcoming']): raise Exception()
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(host, hostDict)
if not valid: continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
quality, info = source_utils.get_release_quality(qual, quality)
info.append('HEVC')
info = ' | '.join(info)
self._sources.append(
{'source': host, 'quality': quality, 'language': 'en', 'url': url, 'info': info,
'direct': False, 'debridonly': True})
except Exception:
pass
except Exception:
pass
except BaseException:
return
def sources(self, url, hostDict, hostprDict):
try:
if url is None:
return sources
sources = []
hostDict = hostprDict + hostDict
r = getSum.get(url)
match = getSum.findSum(r)
for url in match:
if 'vidcloud' in url:
result = getSum.get(url)
match = getSum.findSum(result)
for link in match:
link = "https:" + link if not link.startswith(
'http') else link
link = requests.get(
link).url if 'vidnode' in link else link
valid, host = source_utils.is_host_valid(
link, hostDict)
if valid:
quality, info = source_utils.get_release_quality(
link, link)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': link,
'direct': False,
'debridonly': False
})
else:
valid, host = source_utils.is_host_valid(url, hostDict)
if valid:
quality, info = source_utils.get_release_quality(
url, url)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': url,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
hostDict = hostDict + hostprDict
sources = []
if url is None:
return sources
t = client.request(url)
r = re.compile('data-src-player="(.+?)"').findall(t)
for url in r:
valid, host = source_utils.is_host_valid(url, hostDict)
if valid:
if source_utils.limit_hosts() is True and host in str(
sources):
continue
quality, info = source_utils.get_release_quality(url, url)
sources.append({
'source': host,
'quality': quality,
'language': 'fr',
'url': url,
'info': info,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
hostDict = hostDict + hostprDict
sourcePage = self.scraper.get(url).content
links = re.compile('<iframe.+?src="(.+?)"',
re.DOTALL).findall(sourcePage)
for link in links:
if "gomostream.com" in link:
for source in more_sources.more_gomo(link, hostDict):
sources.append(source)
else:
quality, info = source_utils.get_release_quality(
link, link)
valid, host = source_utils.is_host_valid(link, hostDict)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': link,
'info': info,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
html = self.scraper.get(url).content
links = re.compile('id="linkplayer.+?href="(.+?)"',
re.DOTALL).findall(html)
for link in links:
valid, host = source_utils.is_host_valid(link, hostDict)
if source_utils.limit_hosts() is True and host in str(sources):
continue
if valid:
quality, info = source_utils.get_release_quality(
link, link)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': link,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'tab-plot_german'})
r = dom_parser.parse_dom(r, 'tbody')
r = dom_parser.parse_dom(r, 'tr')
for i in r:
if re.search('(?<=">)(\n.*?)(?=<\/a>)', i[1]).group().strip():
hoster = re.search('(?<=">)(\n.*?)(?=<\/a>)', i[1]).group().strip()
link = re.search('(?<=href=\")(.*?)(?=\")', i[1]).group()
rel = re.search('(?<=oddCell qualityCell">)(\n.*?)(?=<\/td>)', i[1]).group().strip()
quality, info = source_utils.get_release_quality(rel)
if not quality:
quality = 'SD'
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append(
{'source': hoster, 'quality': quality, 'language': 'de', 'url': link, 'direct': False,
'debridonly': False})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
r = self.scraper.get(url).content
qual = re.findall(">(\w+)<\/p", r)
for i in qual:
quality, info = source_utils.get_release_quality(i, i)
r = dom_parser.parse_dom(r, 'div', {'id': 'servers-list'})
r = [dom_parser.parse_dom(i, 'a', req=['href']) for i in r if i]
for i in r[0]:
url = {
'url': i.attrs['href'],
'data-film': i.attrs['data-film'],
'data-server': i.attrs['data-server'],
'data-name': i.attrs['data-name']
}
url = urllib.urlencode(url)
valid, host = source_utils.is_host_valid(i.content, hostDict)
if valid:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': url,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
quality = dom_parser.parse_dom(r, 'span', attrs={'id': 'release_text'})[0].content.split(' ')[0]
quality, info = source_utils.get_release_quality(quality)
r = dom_parser.parse_dom(r, 'ul', attrs={'class': 'currentStreamLinks'})
r = [(dom_parser.parse_dom(i, 'p', attrs={'class': 'hostName'}),
dom_parser.parse_dom(i, 'a', attrs={'class': 'stream-src'}, req='data-id')) for i in r]
r = [(re.sub(' hd$', '', i[0][0].content.lower()), [x.attrs['data-id'] for x in i[1]]) for i in r if
i[0] and i[1]]
for hoster, id in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append({'source': hoster, 'quality': quality, 'language': 'de',
'info': ' | '.join(info + ['' if len(id) == 1 else 'multi-part']), 'url': id,
'direct': False, 'debridonly': False, 'checkquality': True})
return sources
except:
return sources
def _get_sources(self, item):
try:
name = item[0]
quality, info = source_utils.get_release_quality(item[1], name)
info.append(item[2]) # if item[2] != '0'
info = ' | '.join(info)
data = client.request(item[1])
data = client.parseDOM(data, 'a', ret='href')
url = [i for i in data if 'magnet:' in i][0]
url = url.split('&tr')[0]
if any(x in url.lower() for x in [
'french', 'italian', 'spanish', 'truefrench', 'dublado',
'dubbed'
]):
return
self._sources.append({
'source': 'torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('1337X')
pass
def _get_sources(self, item):
try:
name = item[0]
url = item[1]
if any(x in url.lower() for x in [
'french', 'italian', 'spanish', 'truefrench', 'dublado',
'dubbed'
]):
return
quality, info = source_utils.get_release_quality(name, url)
info.append(item[2]) # if item[2] != '0'
info = ' | '.join(info)
self._sources.append({
'source': 'torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('KICKASS2')
pass
def more_gomo(link, hostDict):
sources = [] # By Mpie
try:
gomo_link = 'https://gomostream.com/decoding_v3.php'
User_Agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36'
result = client.request(link)
tc = re.compile('tc = \'(.+?)\';').findall(result)[0]
if (tc):
token = re.compile('"_token": "(.+?)",').findall(result)[0]
post = {'tokenCode': tc, '_token': token}
def tsd(tokenCode):
_13x48X = tokenCode
_71Wxx199 = _13x48X[4:18][::-1]
return _71Wxx199 + "18" + "432782"
headers = {'Host': 'gomostream.com', 'Referer': link, 'User-Agent': User_Agent, 'x-token': tsd(tc)}
result = client.request(gomo_link, XHR=True, post=post, headers=headers)
urls = json.loads(result)
for url in urls:
if 'gomostream' in url:
continue
# sources.append({'source': 'CDN', 'quality': 'SD', 'language': 'en', 'url': url, 'direct': True, 'debridonly': False})
else:
quality, info = source_utils.get_release_quality(url, 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': False})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
hostDict = hostprDict + hostDict
headers = {'Referer': url}
r = self.scraper.get(url, headers=headers).content
u = client.parseDOM(r,
"span",
attrs={"class": "movie_version_link"})
for t in u:
match = client.parseDOM(t, 'a', ret='data-href')
for url in match:
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',
'info': info,
'url': url,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
h = {'User-Agent': client.randomagent()}
html = self.scraper.get(url, headers=h).content
qual = re.compile('<span class="calidad2">(.+?)</span>',
flags=re.DOTALL | re.IGNORECASE).findall(html)[0]
links = re.compile('<iframe src="(.+?)"',
flags=re.DOTALL | re.UNICODE | re.MULTILINE
| re.IGNORECASE).findall(html)
for link in links:
valid, host = source_utils.is_host_valid(link, hostDict)
quality, info = source_utils.get_release_quality(qual, link)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'info': info,
'url': link,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def _get_sources(self, item):
try:
name = item[0]
quality, info = source_utils.get_release_quality(name, name)
info.append(item[2]) # if item[2] != '0'
info = ' | '.join(info)
data = client.request(item[1])
if data is None:
return
try:
url = re.search('''href=["'](magnet:\?[^"']+)''', data).groups()[0]
except:
return
if any(x in url.lower() for x in ['french', 'italian', 'spanish', 'truefrench', 'dublado', 'dubbed']):
return
self._sources.append({'source': 'torrent', 'quality': quality, 'language': 'en', 'url': url,
'info': info, 'direct': False, 'debridonly': True})
except:
source_utils.scraper_error('LIMETORRENTS')
pass
def _get_sources(self, name, url):
try:
headers = {'User-Agent': client.agent()}
r = self.scraper.get(url, headers=headers).content
name = client.replaceHTMLCodes(name)
l = dom_parser.parse_dom(r, 'div', {'class': 'ppu2h'})
s = ''
for i in l:
s += i.content
urls = re.findall(
r'''((?:http|ftp|https)://[\w_-]+(?:(?:\.[\w_-]+)+)[\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])''',
i.content,
flags=re.MULTILINE | re.DOTALL)
urls = [
i for i in urls if '.rar' not in i or '.zip' not in i
or '.iso' not in i or '.idx' not in i or '.sub' not in i
]
for url in urls:
if url in str(self.sources):
continue
valid, host = source_utils.is_host_valid(url, self.hostDict)
if not valid:
continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))',
name)[0]
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)
self.sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('RAPIDMOVIEZ')
pass
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
url = urlparse.urljoin(self.base_link,
url) if not url.startswith('http') else url
result = client.request(url)
data = re.findall(r'\s*(eval.+?)\s*</script', result, re.DOTALL)[1]
data = jsunpack.unpack(data).replace('\\', '')
patern = '''rtv='(.+?)';var aa='(.+?)';var ba='(.+?)';var ca='(.+?)';var da='(.+?)';var ea='(.+?)';var fa='(.+?)';var ia='(.+?)';var ja='(.+?)';var ka='(.+?)';'''
links_url = re.findall(patern, data, re.DOTALL)[0]
slug = 'slug={}'.format(url.split('/')[-1])
links_url = self.base_link + [''.join(links_url)][0].replace(
'slug=', slug)
links = client.request(links_url)
links = client.parseDOM(links, 'tbody')
for i in links:
try:
data = [(client.parseDOM(i, 'a', ret='href')[0],
client.parseDOM(i,
'span',
attrs={'class':
'version_host'})[0])][0]
url = urlparse.urljoin(self.base_link, data[0])
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
host = data[1]
valid, host = source_utils.is_host_valid(host, hostDict)
if not valid:
raise Exception()
quality = client.parseDOM(i, 'span', ret='class')[0]
quality, info = source_utils.get_release_quality(
quality, url)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except BaseException:
pass
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url: return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['title']
year = data['year']
t = title + year
query = '%s' % data['title']
query = re.sub(r'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link.format(urllib.quote_plus(query))
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
items = client.parseDOM(r, 'li')
items = [(dom.parse_dom(i, 'a', req='href')[0]) for i in items
if year in i]
items = [(i.attrs['href'], re.sub('<.+?>|\n', '',
i.content).strip())
for i in items]
item = [
i[0].replace('movie', 'view') for i in items
if cleantitle.get(t) == cleantitle.get(i[1])
][0]
html = client.request(item)
streams = re.findall('sources\:\s*\[(.+?)\]\,', html, re.DOTALL)[0]
streams = re.findall(
'file:\s*[\'"](.+?)[\'"].+?label:\s*[\'"](.+?)[\'"]', streams,
re.DOTALL)
for link, label in streams:
quality = source_utils.get_release_quality(label, label)[0]
link += '|User-Agent=%s&Referer=%s' % (urllib.quote(
client.agent()), item)
sources.append({
'source': 'Direct',
'quality': quality,
'language': 'en',
'url': link,
'direct': True,
'debridonly': False
})
return sources
except BaseException:
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])
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 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):
sources = []
try:
if not url:
return sources
url = urlparse.urljoin(self.base_link, url)
r = self.scraper.get(url).content
rel = dom_parser.parse_dom(r, 'div', attrs={'id': 'info'})
rel = dom_parser.parse_dom(rel,
'div',
attrs={'itemprop': 'description'})
rel = dom_parser.parse_dom(rel, 'p')
rel = [re.sub('<.+?>|</.+?>', '', i.content) for i in rel]
rel = [re.findall('release:\s*(.*)', i, re.I) for i in rel]
rel = [source_utils.get_release_quality(i[0]) for i in rel if i]
quality, info = (rel[0]) if rel else ('SD', [])
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'links'})
r = dom_parser.parse_dom(r, 'table')
r = dom_parser.parse_dom(r, 'tr', attrs={'id': re.compile('\d+')})
r = [dom_parser.parse_dom(i, 'td') for i in r]
r = [(i[0], re.sub('<.+?>|</.+?>', '', i[1].content).strip())
for i in r if len(r) >= 1]
r = [(dom_parser.parse_dom(i[0], 'a', req='href'), i[1])
for i in r]
r = [(i[0][0].attrs['href'], i[1]) for i in r if i[0]]
info = ' | '.join(info)
for link, hoster in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append({
'source': hoster,
'quality': quality,
'language': 'de',
'url': link,
'info': info,
'direct': False,
'debridonly': False,
'checkquality': True
})
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])
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):
try:
sources = []
hostDict = hostprDict + hostDict
r = client.request(url)
match = re.compile('<td align="center"><strong><a href="(.+?)"').findall(r)
for url in match:
valid, host = source_utils.is_host_valid(url, hostDict)
if valid:
quality, info = source_utils.get_release_quality(url, url)
sources.append({'source': host, 'quality': quality, 'language': 'en', 'url': url, 'info': info,
'direct': False, 'debridonly': False})
return sources
except Exception:
return sources
def _get_sources(self, url):
try:
item = client.request(url[0])
title = url[1]
links = dom_parser2.parse_dom(item, 'a', req='href')
links = [i.attrs['href'] for i in links]
info = []
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))', item)[0]
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)
for url in links:
if 'youtube' in url: continue
if any(x in url.lower()
for x in ['.rar.', '.zip.', '.iso.']) or any(
url.lower().endswith(x)
for x in ['.rar', '.zip', '.iso']):
raise Exception()
if any(x in url.lower()
for x in ['youtube', 'sample', 'trailer']):
raise Exception()
valid, host = source_utils.is_host_valid(url, self.hostDict)
if not valid: continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
quality, info2 = source_utils.get_release_quality(title, url)
if url in str(self._sources): continue
self._sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except Exception:
pass
def _get_sources(self, url):
try:
r = client.request(url)
posts = client.parseDOM(r, 'tr')
for post in posts:
link = re.findall('a title="Download Torrent Magnet" href="(magnet:.+?)"', post, re.DOTALL)
if link == []:
continue
for url in link:
url = url.split('&tr')[0]
if any(x in url.lower() for x in ['french', 'italian', 'spanish', 'truefrench', 'dublado', 'dubbed']):
continue
name = url.split('&dn=')[1]
name = urllib.unquote_plus(name)
t = name.split(self.hdlr)[0].replace(self.year, '').replace('(', '').replace(')', '').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(self.title):
continue
if self.hdlr not in url:
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)) / div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
self.sources.append({'source': 'torrent', 'quality': quality, 'language': 'en', 'url': url,
'info': info, 'direct': False, 'debridonly': True})
except:
source_utils.scraper_error('BTSCENE')
pass
