def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None:
return sources
r = cache.get(client.request, 1, url)
try:
v = re.findall('document.write\(Base64.decode\("(.+?)"\)',
r)[0]
b64 = base64.b64decode(v)
url = client.parseDOM(b64, 'iframe', ret='src')[0]
try:
host = re.findall('([\w]+[.][\w]+)$',
urlparse(url.strip().lower()).netloc)[0]
host = client.replaceHTMLCodes(host)
try:
host = host.encode('utf-8')
except:
pass
valid, host = source_utils.is_host_valid(host, hostDict)
if valid:
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url.replace('\/', '/'),
'direct': False,
'debridonly': False
})
except:
pass
except:
pass
r = client.parseDOM(r, 'div', {'class': 'server_line'})
r = [(client.parseDOM(i, 'a', ret='href')[0],
client.parseDOM(i, 'p', attrs={'class':
'server_servername'})[0])
for i in r]
if r:
for i in r:
try:
host = re.sub('Server|Link\s*\d+', '', i[1]).lower()
url = i[0]
host = client.replaceHTMLCodes(host)
try:
host = host.encode('utf-8')
except:
pass
if 'other' in host:
continue
if source_utils.limit_hosts() is True and host in str(
sources):
continue
valid, host = source_utils.is_host_valid(
host, hostDict)
if valid:
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url.replace('\/', '/'),
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
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])
url = urlparse.urljoin(self.base_link, data.get('url'))
episode = data.get('episode')
r = client.request(url)
aj = self.__get_ajax_object(r)
b = dom_parser.parse_dom(r,
'img',
attrs={'class': 'dgvaup'},
req='data-img')[0].attrs['data-img']
if episode:
r = dom_parser.parse_dom(r,
'a',
attrs={
'class': 'btn-stream-ep',
'data-episode': episode
},
req=['data-episode', 'data-server'])
else:
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'lang-de'})
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'movie'})
r = dom_parser.parse_dom(r,
'a',
attrs={'class': 'btn-stream'},
req=['data-episode', 'data-server'])
r = [(i.attrs['data-episode'], i.attrs['data-server']) for i in r]
for epi, server in r:
try:
x = {
'action': aj.get('load_episodes'),
'episode': epi,
'pid': aj.get('postid'),
'server': server,
'nonce': aj.get('nonce'),
'b': b
}
x = client.request(aj.get('ajax_url'),
post=x,
XHR=True,
referer=url)
x = json.loads(x)
q = source_utils.label_to_quality(x.get('q'))
x = json.loads(base64.decodestring(x.get('u')))
u = source_utils.evp_decode(x.get('ct'),
base64.decodestring(b),
x.get('s').decode("hex"))
u = u.replace('\/', '/').strip('"')
valid, host = source_utils.is_host_valid(u, hostDict)
if not valid: continue
sources.append({
'source': host,
'quality': q,
'language': 'de',
'url': u,
'direct': False,
'debridonly': False,
'checkquality': True
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
hostDict = hostDict + hostprDict
sources = []
query_bases = []
options = []
if url is None:
return sources
if not debrid.status():
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'])
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
# tvshowtitle
if 'tvshowtitle' in data:
query_bases.append('%s ' % (data['tvshowtitle'].replace("-", "")))
if 'year' in data:
query_bases.append('%s %s ' % (data['tvshowtitle'], data['year']))
options.append('S%02dE%02d' % (int(data['season']), int(data['episode'])))
options.append('S%02d' % (int(data['season'])))
else:
query_bases.append('%s %s ' % (data['title'], data['year']))
query_bases.append('%s ' % (data['title']))
query_bases.append('2160p')
query_bases.append('')
for option in options:
for query_base in query_bases:
q = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query_base + option)
q = q.replace(" ", " ").replace(" ", "+")
url = self.base_link + self.search_link % q
html = self.scraper.get(url)
if html.status_code == 200:
posts = client.parseDOM(html.content, "div", attrs={"class": "title"})
for post in posts:
url = client.parseDOM(post, "a", ret='href')
if len(url) > 0:
html = self.scraper.get(url[0])
if html.status_code == 200:
quotes = client.parseDOM(html.content, "div", attrs={"class": "dlinks"})
for quote in quotes:
hrefs = client.parseDOM(quote, "a", ret='href')
if not hrefs:
continue
for href in hrefs:
quality = source_utils.check_sd_url(href)
href = href.encode('utf-8')
valid, host = source_utils.is_host_valid(href, hostDict)
if any(x in href for x in ['.rar', '.zip', '.iso']):
continue
if not valid:
continue
if hdlr in href.upper() and cleantitle.get(title) in cleantitle.get(href):
sources.append(
{'source': host, 'quality': quality, 'language': 'en', 'url': href,
'direct': False, 'debridonly': False})
if len(sources) > 0:
return sources
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
typ = url[4]
headers = {
"User-Agent":
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0",
"http.content_type":
"application/x-www-form-urlencoded; charset=UTF-8"
}
data = ''
if typ == "SERIAL":
title = url[0]
id = url[1]
year = url[2]
orgtitle = url[3]
sezon = url[5]
epizod = url[6]
if orgtitle != "0":
data = {
"id": int(id),
"type": typ,
"title": title,
"year": int(year),
"sezon": str(sezon),
"odcinek": str(epizod),
"site": "filmdb",
"browser": "chrome"
}
else:
data = {
"id": int(id),
"type": typ,
"title": title,
"originalTitle": str(orgtitle),
"year": int(year),
"sezon": str(sezon),
"odcinek": str(epizod),
"site": "filmdb",
"browser": "chrome"
}
if typ == "FILM":
title = url[0]
id = url[1]
year = url[2]
orgtitle = url[3]
if orgtitle != "0":
data = {
"id": int(id),
"type": typ,
"title": str(title),
"originalTitle": str(orgtitle),
"year": int(year),
"site": "filmdb",
"browser": "chrome"
}
else:
data = {
"id": int(id),
"type": typ,
"title": str(title),
"year": int(year),
"site": "filmdb",
"browser": "chrome"
}
data = {"json": json.dumps(data, ensure_ascii=False)}
response = requests.post("http://fboost.pl/api/api.php",
data=data,
headers=headers)
content = json.loads(response.content)
for code in zip(content[u'link'], content[u'wersja']):
wersja = str(code[1])
lang, info = self.get_lang_by_type(wersja)
test = requests.post("http://fboost.pl/api/player.php?src=%s" %
code[0]).content
link = re.search("""iframe src="(.*)" style""", test)
link = link.group(1)
if len(link) < 2:
continue
if "cda.pl" in link:
try:
response = requests.get(link).content
test = client.parseDOM(
response, 'div', attrs={'class': 'wrapqualitybtn'})
urls = client.parseDOM(test, 'a', ret='href')
for url in urls:
valid, host = source_utils.is_host_valid(
url, hostDict)
q = source_utils.check_url(url)
sources.append({
'source': host,
'quality': q,
'language': lang,
'url': url,
'info': info,
'direct': False,
'debridonly': False
})
continue
except:
pass
if "rapidvideo.com" in link:
try:
response = requests.get(link).content
test = re.findall(
"""(https:\/\/www.rapidvideo.com\/e\/.*)">""",
response)
numGroups = len(test)
for i in range(1, numGroups):
url = test[i]
valid, host = source_utils.is_host_valid(
url, hostDict)
q = source_utils.check_url(url)
sources.append({
'source': host,
'quality': q,
'language': lang,
'url': url,
'info': info,
'direct': False,
'debridonly': False
})
continue
except:
pass
valid, host = source_utils.is_host_valid(link, hostDict)
q = source_utils.check_url(link)
sources.append({
'source': host,
'quality': q,
'language': lang,
'url': link,
'info': info,
'direct': False,
'debridonly': False
})
return sources
except:
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])
url = data.get('url')
episode = int(data.get('episode', 1))
r = client.request(urlparse.urljoin(self.base_link, url))
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'streams'})
rels = dom_parser.parse_dom(r, 'ul', attrs={'class': 'nav'})
rels = dom_parser.parse_dom(rels, 'li')
rels = dom_parser.parse_dom(
rels,
'a',
attrs={'href': re.compile('#stream_\d*')},
req='href')
rels = [(re.findall('stream_(\d+)', i.attrs['href']),
re.findall('flag-(\w{2})', i.content)) for i in rels if i]
rels = [(i[0][0], ['subbed'] if i[1][0] != 'de' else [])
for i in rels if i[0] and 'de' in i[1]]
for id, info in rels:
rel = dom_parser.parse_dom(r,
'div',
attrs={'id': 'stream_%s' % id})
rel = [(dom_parser.parse_dom(
i, 'div', attrs={'id': 'streams_episodes_%s' % id}),
dom_parser.parse_dom(i, 'tr')) for i in rel]
rel = [(i[0][0].content,
[x for x in i[1] if 'fa-desktop' in x.content])
for i in rel if i[0] and i[1]]
rel = [(i[0], dom_parser.parse_dom(i[1][0].content, 'td'))
for i in rel if i[1]]
rel = [(i[0], re.findall('\d{3,4}x(\d{3,4})$',
i[1][0].content)) for i in rel
if i[1]]
rel = [(i[0], source_utils.label_to_quality(i[1][0]))
for i in rel if len(i[1]) > 0]
for html, quality in rel:
try:
s = dom_parser.parse_dom(
html,
'a',
attrs={
'href':
re.compile('#streams_episodes_%s_\d+' % id)
})
s = [(dom_parser.parse_dom(
i,
'div',
attrs={'data-loop': re.compile('\d+')},
req='data-loop'), dom_parser.parse_dom(i, 'span'))
for i in s]
s = [(i[0][0].attrs['data-loop'], [
x.content for x in i[1] if '<strong' in x.content
]) for i in s if i[0]]
s = [(i[0],
re.findall('<.+?>(\d+)</.+?> (.+?)$', i[1][0]))
for i in s if len(i[1]) > 0]
s = [(i[0], i[1][0]) for i in s if len(i[1]) > 0]
s = [(i[0], int(i[1][0]),
re.findall('Episode (\d+):',
i[1][1]), re.IGNORECASE) for i in s
if len(i[1]) > 1]
s = [(i[0], i[1],
int(i[2][0]) if len(i[2]) > 0 else -1)
for i in s]
s = [(i[0], i[2] if i[2] >= 0 else i[1]) for i in s]
s = [i[0] for i in s if i[1] == episode][0]
enc = dom_parser.parse_dom(
html,
'div',
attrs={
'id':
re.compile('streams_episodes_%s_%s' % (id, s))
},
req='data-enc')[0].attrs['data-enc']
hosters = dom_parser.parse_dom(
html,
'a',
attrs={
'href':
re.compile('#streams_episodes_%s_%s' % (id, s))
})
hosters = [
dom_parser.parse_dom(i, 'i', req='class')
for i in hosters
]
hosters = [
re.findall('hoster-(\w+)',
' '.join([x.attrs['class'] for x in i]))
for i in hosters if i
][0]
hosters = [(source_utils.is_host_valid(
re.sub('(co|to|net|pw|sx|tv|moe|ws|icon)$', '', i),
hostDict), i) for i in hosters]
hosters = [(i[0][1], i[1]) for i in hosters
if i[0] and i[0][0]]
info = ' | '.join(info)
for source, hoster in hosters:
sources.append({
'source': source,
'quality': quality,
'language': 'de',
'url': [enc, hoster],
'info': info,
'direct': False,
'debridonly': False,
'checkquality': True
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
rels = dom_parser.parse_dom(r, 'nav', attrs={'class': 'player'})
rels = dom_parser.parse_dom(rels, 'ul', attrs={'class': 'idTabs'})
rels = dom_parser.parse_dom(rels, 'li')
rels = [(dom_parser.parse_dom(i,
'a',
attrs={'class': 'options'},
req='href'),
dom_parser.parse_dom(i, 'img', req='src')) for i in rels]
rels = [(i[0][0].attrs['href'][1:],
re.findall('/flags/(\w+)\.png$', i[1][0].attrs['src']))
for i in rels if i[0] and i[1]]
rels = [
i[0] for i in rels if len(i[1]) > 0 and i[1][0].lower() == 'de'
]
r = [dom_parser.parse_dom(r, 'div', attrs={'id': i}) for i in rels]
r = [(re.findall('link"?\s*:\s*"(.+?)"',
''.join([x.content for x in i])),
dom_parser.parse_dom(i,
'iframe',
attrs={'class': 'metaframe'},
req='src')) for i in r]
r = [
i[0][0] if i[0] else i[1][0].attrs['src'] for i in r
if i[0] or i[1]
]
for i in r:
try:
i = re.sub('\[.+?\]|\[/.+?\]', '', i)
i = client.replaceHTMLCodes(i)
if not i.startswith('http'): i = self.__decode_hash(i)
if 'play.seriesever' in i:
i = client.request(i)
i = dom_parser.parse_dom(i, 'iframe', req='src')
if len(i) < 1: continue
i = i[0].attrs['src']
valid, host = source_utils.is_host_valid(i, hostDict)
if not valid: continue
urls, host, direct = source_utils.check_directstreams(
i, host)
for x in urls:
sources.append({
'source': host,
'quality': x['quality'],
'language': 'de',
'url': x['url'],
'direct': direct,
'debridonly': False
})
except:
pass
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
hostDict = hostprDict + hostDict
data = 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 % quote_plus(query)
url = urljoin(self.base_link, url).replace('-', '+')
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
posts = client.parseDOM(r, "div", attrs={"class": "item-post"})
posts = client.parseDOM(posts, "h3")
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')[0]
name1 = u.split('https://onceddl.org/')[1].rstrip('/')
name1 = re.sub('[^A-Za-z0-9]+', '.', name1)
r = client.request(u)
u = client.parseDOM(r,
"div",
attrs={"class": "single-link"})
for t in u:
r = client.parseDOM(t, 'a', ret='href')
for url in r:
if any(x in url for x in
['.rar', '.zip', '.iso', '.sample.']):
continue
valid, host = source_utils.is_host_valid(
url, hostDict)
if valid:
if 'OnceDDL_' in url:
name = url.split('OnceDDL_')[1]
name = re.sub('[^A-Za-z0-9]+', '.', name)
else:
name = name1
if source_utils.remove_lang(name):
continue
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
if url in str(sources):
continue
quality, info = source_utils.get_release_quality(
name, url)
# size info not available on onceddl
dsize = 0
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize
})
except:
source_utils.scraper_error('ONCEDDL')
pass
return sources
except:
source_utils.scraper_error('ONCEDDL')
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])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
if 'season' in data:
season = data['season']
if 'episode' in data:
episode = data['episode']
year = data['year']
r = client.request(self.base_link, output='extended', timeout='10')
cookie = r[4];
headers = r[3];
result = r[0]
headers['Cookie'] = cookie
query = urlparse.urljoin(self.base_link,
self.search_link % urllib.quote_plus(cleantitle.getsearch(title)))
r = client.request(query, headers=headers, XHR=True)
r = json.loads(r)['content']
r = zip(client.parseDOM(r, 'a', ret='href'), client.parseDOM(r, 'a'))
if 'tvshowtitle' in data:
cltitle = cleantitle.get(title + 'season' + season)
cltitle2 = cleantitle.get(title + 'season%02d' % int(season))
r = [i for i in r if cltitle == cleantitle.get(i[1]) or cltitle2 == cleantitle.get(i[1])]
vurl = '%s%s-episode-%s' % (self.base_link, str(r[0][0]).replace('/info', ''), episode)
vurl2 = None
else:
cltitle = cleantitle.getsearch(title)
cltitle2 = cleantitle.getsearch('%s (%s)' % (title, year))
r = [i for i in r if
cltitle2 == cleantitle.getsearch(i[1]) or cltitle == cleantitle.getsearch(i[1])]
vurl = '%s%s-episode-0' % (self.base_link, str(r[0][0]).replace('/info', ''))
vurl2 = '%s%s-episode-1' % (self.base_link, str(r[0][0]).replace('/info', ''))
r = client.request(vurl, headers=headers)
headers['Referer'] = vurl
slinks = client.parseDOM(r, 'div', attrs={'class': 'anime_muti_link'})
slinks = client.parseDOM(slinks, 'li', ret='data-video')
if len(slinks) == 0 and not vurl2 == None:
r = client.request(vurl2, headers=headers)
headers['Referer'] = vurl2
slinks = client.parseDOM(r, 'div', attrs={'class': 'anime_muti_link'})
slinks = client.parseDOM(slinks, 'li', ret='data-video')
for slink in slinks:
try:
if 'vidnode.net/streaming.php' in slink:
r = client.request('https:%s' % slink, headers=headers)
clinks = re.findall(r'sources:\[(.*?)\]', r)[0]
clinks = re.findall(r'file:\s*\'(http[^\']+)\',label:\s*\'(\d+)', clinks)
for clink in clinks:
q = source_utils.label_to_quality(clink[1])
sources.append(
{'source': 'cdn', 'quality': q, 'language': 'en', 'url': clink[0], 'direct': True,
'debridonly': False})
else:
quality = source_utils.check_url(slink)
valid, hoster = source_utils.is_host_valid(slink, hostDict)
if valid:
sources.append({'source': hoster, 'quality': quality, 'language': 'en', 'url': slink,
'direct': False, 'debridonly': False})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'watch_video'})
r = [
i.attrs['data-src']
for i in dom_parser.parse_dom(r, 'iframe', req='data-src')
]
for i in r:
try:
if 'k-vid' in i:
i = client.request(i, referer=url)
i = dom_parser.parse_dom(
i, 'div', attrs={'class': 'videocontent'})
gvid = dom_parser.parse_dom(i, 'source', req='src')
gvid = [
(g.attrs['src'],
g.attrs['label'] if 'label' in g.attrs else 'SD')
for g in gvid
]
gvid = [(x[0], source_utils.label_to_quality(x[1]))
for x in gvid if x[0] != 'auto']
for u, q in gvid:
try:
tag = directstream.googletag(u)
if tag:
sources.append({
'source':
'gvideo',
'quality':
tag[0].get('quality', 'SD'),
'language':
'ko',
'url':
u,
'direct':
True,
'debridonly':
False
})
else:
sources.append({
'source': 'CDN',
'quality': q,
'language': 'ko',
'url': u,
'direct': True,
'debridonly': False
})
except:
pass
i = dom_parser.parse_dom(i,
'iframe',
attrs={'id': 'embedvideo'},
req='src')[0].attrs['src']
valid, host = source_utils.is_host_valid(i, hostDict)
if not valid: continue
sources.append({
'source': host,
'quality': 'SD',
'language': 'ko',
'url': i,
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
url = urlparse.urljoin(self.base_link, data.get('url'))
season = data.get('season')
episode = data.get('episode')
r = client.request(url)
if season and episode:
r = dom_parser.parse_dom(r,
'select',
attrs={'id': 'SeasonSelection'},
req='rel')[0]
r = client.replaceHTMLCodes(r.attrs['rel'])[1:]
r = urlparse.parse_qs(r)
r = dict([(i, r[i][0]) if r[i] else (i, '') for i in r])
r = urlparse.urljoin(
self.base_link, self.get_links_epi %
(r['Addr'], r['SeriesID'], season, episode))
r = client.request(r)
r = dom_parser.parse_dom(r, 'ul', attrs={'id': 'HosterList'})[0]
r = dom_parser.parse_dom(r,
'li',
attrs={'id': re.compile('Hoster_\d+')},
req='rel')
r = [(client.replaceHTMLCodes(i.attrs['rel']), i.content)
for i in r if i[0] and i[1]]
r = [(i[0],
re.findall('class="Named"[^>]*>([^<]+).*?(\d+)/(\d+)', i[1]))
for i in r]
r = [(i[0], i[1][0][0].lower().rsplit('.', 1)[0], i[1][0][2])
for i in r if len(i[1]) > 0]
for link, hoster, mirrors in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
u = urlparse.parse_qs('&id=%s' % link)
u = dict([(x, u[x][0]) if u[x] else (x, '') for x in u])
for x in range(0, int(mirrors)):
url = self.mirror_link % (u['id'], u['Hoster'], x + 1)
if season and episode:
url += "&Season=%s&Episode=%s" % (season, episode)
try:
sources.append({
'source': hoster,
'quality': 'SD',
'language': 'de',
'url': url,
'direct': False,
'debridonly': False
})
except:
pass
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 = urlparse.urljoin(self.base_link, self.search_link)
# url = url % urllib.quote_plus(query)
url = url % urllib.quote(query)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
r = client.parseDOM(r, 'h2')
# z = zip(client.parseDOM(r, 'a', ret='href'), client.parseDOM(r, 'a', ret='title'))
z = zip(client.parseDOM(r, 'a', ret='href'),
client.parseDOM(r, 'a'))
if 'tvshowtitle' in data:
posts = [(i[1], i[0]) for i in z]
else:
posts = [(i[1], i[0]) for i in z]
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
try:
t = post[0].encode('utf-8')
except:
t = post[0]
u = client.request(post[1])
u = re.findall('\'(http.+?)\'', u) + re.findall(
'\"(http.+?)\"', u)
u = [i for i in u if '/embed/' not in i]
u = [i for i in u if 'youtube' not in i]
try:
s = re.search(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
post)
s = s.groups()[0] if s else '0'
except:
s = '0'
pass
items += [(t, i, s) for i in u]
except:
source_utils.scraper_error('MYVIDEOLINK')
pass
for item in items:
try:
url = item[1]
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
void = ('.rar', '.zip', '.iso', '.part', '.png', '.jpg',
'.bmp', '.gif')
if url.endswith(void):
continue
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
name = item[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
if hdlr not in name:
continue
quality, info = source_utils.get_release_quality(name, url)
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)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
source_utils.scraper_error('MYVIDEOLINK')
pass
return sources
except:
source_utils.scraper_error('MYVIDEOLINK')
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:
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('%3A+', '+')
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)
except:
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)
#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 sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
url = urlparse.urljoin(self.base_link, url)
r = client.request(url, output='extended')
headers = r[3]
headers.update({
'Cookie': r[2].get('Set-Cookie'),
'Referer': self.base_link
})
r = r[0]
rels = dom_parser.parse_dom(r, 'nav', attrs={'class': 'player'})
rels = dom_parser.parse_dom(rels, 'ul', attrs={'class': 'idTabs'})
rels = dom_parser.parse_dom(rels, 'li')
rels = [(dom_parser.parse_dom(i,
'a',
attrs={'class': 'options'},
req='href'),
dom_parser.parse_dom(i, 'img', req='src')) for i in rels]
rels = [(i[0][0].attrs['href'][1:],
re.findall('/flags/(\w+)\.png$', i[1][0].attrs['src']))
for i in rels if i[0] and i[1]]
rels = [
i[0] for i in rels if len(i[1]) > 0 and i[1][0].lower() == 'de'
]
r = [dom_parser.parse_dom(r, 'div', attrs={'id': i}) for i in rels]
links = re.findall('''(?:link|file)["']?\s*:\s*["'](.+?)["']''',
''.join([i[0].content for i in r]))
links += [
l.attrs['src'] for i in r for l in dom_parser.parse_dom(
i, 'iframe', attrs={'class': 'metaframe'}, req='src')
]
links += [
l.attrs['src'] for i in r
for l in dom_parser.parse_dom(i, 'source', req='src')
]
for i in links:
try:
i = re.sub('\[.+?\]|\[/.+?\]', '', i)
i = client.replaceHTMLCodes(i)
if '/play/' in i: i = urlparse.urljoin(self.base_link, i)
if self.domains[0] in i:
i = client.request(i, headers=headers, referer=url)
for x in re.findall('''\(["']?(.*)["']?\)''', i):
try:
i += jsunpack.unpack(
base64.decodestring(
re.sub('"\s*\+\s*"', '',
x))).replace('\\', '')
except:
pass
for x in re.findall('(eval\s*\(function.*?)</script>',
i, re.DOTALL):
try:
i += jsunpack.unpack(x).replace('\\', '')
except:
pass
links = [(match[0], match[1]) for match in re.findall(
'''['"]?file['"]?\s*:\s*['"]([^'"]+)['"][^}]*['"]?label['"]?\s*:\s*['"]([^'"]*)''',
i, re.DOTALL)]
links = [(x[0].replace('\/', '/'),
source_utils.label_to_quality(x[1]))
for x in links if '/no-video.mp4' not in x[0]]
doc_links = [
directstream.google(
'https://drive.google.com/file/d/%s/view' %
match)
for match in re.findall(
'''file:\s*["'](?:[^"']+youtu.be/([^"']+))''',
i, re.DOTALL)
]
doc_links = [(u['url'], u['quality'])
for x in doc_links if x for u in x]
links += doc_links
for url, quality in links:
if self.base_link in url:
url = url + '|Referer=' + self.base_link
sources.append({
'source': 'gvideo',
'quality': quality,
'language': 'de',
'url': url,
'direct': True,
'debridonly': False
})
else:
try:
# as long as resolveurl get no Update for this URL (So just a Temp-Solution)
did = re.findall(
'youtube.googleapis.com.*?docid=(\w+)', i)
if did:
i = 'https://drive.google.com/file/d/%s/view' % did[
0]
valid, host = source_utils.is_host_valid(
i, hostDict)
if not valid: continue
urls, host, direct = source_utils.check_directstreams(
i, host)
for x in urls:
sources.append({
'source': host,
'quality': x['quality'],
'language': 'de',
'url': x['url'],
'direct': direct,
'debridonly': False
})
except:
pass
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
sources = []
if url == None: 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']
query = '%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)
posts = client.parseDOM(r, 'item')
for post in posts:
try:
name = client.parseDOM(post, 'title')
links = client.parseDOM(post, 'a', ret='href')
t = re.sub('(\.|\(|\[|\s|)(\d{4})(\.|\)|\]|\s|)(.+|)', '',
name[0])
if not cleantitle.get(t) == cleantitle.get(title):
raise Exception()
y = re.findall('\(\s*(\d{4})\s*\)', name[0])[0]
if not y == year: raise Exception()
for url in links:
if any(x in url for x in [
'.online', 'xrysoi.se', 'filmer', '.bp',
'.blogger'
]):
continue
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(url, hostDict)
if 'hdvid' in host: valid = True
if not valid: continue
quality = 'SD'
info = 'SUB'
sources.append({
'source': host,
'quality': quality,
'language': 'gr',
'url': url,
'info': info,
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
try:
search_url = url['url']
post = url['post']
referer = urlparse.urljoin(self.film_web, post['urlstrony'])
result = self.scraper.post(search_url,
data=post,
headers={
'referer': referer
}).content
if not result.startswith('http'):
return sources
valid, host = source_utils.is_host_valid(result, hostDict)
q = source_utils.check_sd_url(result)
info = ''
if 'lektor' in result:
info = 'Lektor'
if 'napisy' in result:
info = 'Napisy'
first_found = {
'source': host,
'quality': '720p',
'language': 'pl',
'url': result,
'info': info,
'direct': False,
'debridonly': False
}
first_found['info'] = self.get_info_from_others(sources)
sources.append(first_found)
except:
pass
search_more_post = url['more']
# search_url = urlparse.urljoin(self.base_link, self.search_more)
result = self.scraper.post(self.base_link2,
data=search_more_post).content
provider = client.parseDOM(result, 'option', ret='value')
links = client.parseDOM(result, 'div', ret='data')
wersja = client.parseDOM(result, 'div', attrs={'class': 'wersja'})
# result = dom_parser.parse_dom(result, 'a')
counter = 0
for link in links:
valid, host = source_utils.is_host_valid(link, hostDict)
if not valid: continue
q = source_utils.check_sd_url(link)
sources.append({
'source': host,
'quality': q,
'language': 'pl',
'url': link,
'info': wersja[counter],
'direct': False,
'debridonly': False
})
counter += 1
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 %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)
posts = client.parseDOM(r, 'h2')
hostDict = hostprDict + hostDict
urls = []
for item in posts:
try:
item = re.compile('a href="(.+?)"').findall(item)
name = item[0]
query = query.replace(" ", "-").lower()
if query not in name:
continue
name = client.replaceHTMLCodes(name)
quality, info = source_utils.get_release_quality(name, item[0])
if any(x in quality for x in ['CAM', 'SD']):
continue
url = item
links = self.links(url)
urls += [(i, quality, info) for i in links]
except:
pass
for item in urls:
if 'earn-money' in item[0]:
continue
if any(x in item[0] for x in ['.rar', '.zip', '.iso']):
continue
url = client.replaceHTMLCodes(item[0])
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({'source': host, 'quality': item[1], 'language': 'en', 'url': url, 'direct': False,
'debridonly': True})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
hostDict += [
'akamaized.net', 'google.com', 'picasa.com', 'blogspot.com'
]
result = self.scraper.get(url, timeout=10).content
dom = dom_parser.parse_dom(result, 'a', req='data-video')
urls = [
i.attrs['data-video']
if i.attrs['data-video'].startswith('https') else 'https:' +
i.attrs['data-video'] for i in dom
]
for url in urls:
dom = []
if 'vidnode.net' in url:
result = self.scraper.get(url, timeout=10).content
dom = dom_parser.parse_dom(result,
'source',
req=['src', 'label'])
dom = [
(i.attrs['src'] if i.attrs['src'].startswith('https')
else 'https:' + i.attrs['src'], i.attrs['label'])
for i in dom if i
]
elif 'ocloud.stream' in url:
result = self.scraper.get(url, timeout=10).content
base = re.findall('<base href="([^"]+)">', result)[0]
hostDict += [base]
dom = dom_parser.parse_dom(result, 'a', req=['href', 'id'])
dom = [(i.attrs['href'].replace('./embed', base + 'embed'),
i.attrs['id']) for i in dom if i]
dom = [(re.findall("var\s*ifleID\s*=\s*'([^']+)",
client.request(i[0]))[0], i[1])
for i in dom if i]
if dom:
try:
for r in dom:
valid, hoster = source_utils.is_host_valid(
r[0], hostDict)
if not valid: continue
quality = source_utils.label_to_quality(r[1])
urls, host, direct = source_utils.check_directstreams(
r[0], hoster)
for x in urls:
if direct:
size = source_utils.get_size(x['url'])
if size:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': x['url'],
'direct': direct,
'debridonly': False,
'info': size
})
else:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': x['url'],
'direct': direct,
'debridonly': False
})
except:
pass
else:
valid, hoster = source_utils.is_host_valid(url, hostDict)
if not valid: continue
try:
url.decode('utf-8')
sources.append({
'source': hoster,
'quality': 'SD',
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
data = parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['tvshowtitle']
hdlr = 's%02de%02d' % (int(data['season']), int(data['episode']))
query = quote_plus(cleantitle.getsearch(title))
surl = urljoin(self.base_link, self.search_link % query)
r = client.request(surl, XHR=True, timeout='10')
if not r:
return sources
r = json.loads(r)
r = r['series']
for i in r:
tit = i['original_name']
if cleantitle.get(title) != cleantitle.get(tit):
continue
slink = '/' + i['seo_name']
slink = urljoin(self.base_link, slink)
r = client.request(slink, timeout='10')
data = client.parseDOM(r, 'div', attrs={'class': 'el-item\s*'})
ep = [
i for i in client.parseDOM(data, 'a', ret='href')
if hdlr in i.lower()
][0]
r = client.request(ep, timeout='10')
links = client.parseDOM(r,
'a',
attrs={'class': 'watch-button'},
ret='href')
for link in links:
list = client.request(link, timeout='10')
if not list:
continue
url = client.parseDOM(
list,
'a',
attrs={'class': 'watch-button actWatched'},
ret='href')[0]
try:
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
continue
sources.append({
'source': host,
'quality': '720p',
'info': '',
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except:
source_utils.scraper_error('WATCHEPISODESERIES1')
return sources
return sources
except:
source_utils.scraper_error('WATCHEPISODESERIES1')
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])
url = self.searchMovie(data['title'], data['year'])
if url is None: return sources
r = client.request(url)
data = client.parseDOM(r, 'div', attrs={'class': 'playex'})[0]
frames = client.parseDOM(data, 'iframe', ret='src')
frames += re.compile('''<iframe\s*src=['"](.+?)['"]''',
re.DOTALL).findall(data)
quality = client.parseDOM(r, 'span', attrs={'class':
'qualityx'})[0]
for frame in frames:
url = frame.split('=')[1] if frame.startswith('<') else frame
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(url, hostDict)
if valid:
quality, info = source_utils.get_release_quality(
quality, url)
info = ' | '.join(info)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': False
})
elif url.endswith('mp4'):
url += '|User-Agent=%s' % urllib.quote_plus(client.agent())
sources.append({
'source': 'MP4',
'quality': quality,
'language': 'en',
'url': url,
'direct': True,
'debridonly': False
})
elif 'mystream' in url:
data = client.request(url)
links = dom_parser.parse_dom(data,
'source',
req=['src', 'label'])
for link in links:
label = link.attrs['label']
url = link.attrs[
'src'] + '|User-Agent=%s' % urllib.quote_plus(
client.agent())
sources.append({
'source': 'MYSTREAM',
'quality': label,
'language': 'en',
'url': url,
'direct': True,
'debridonly': False
})
else:
continue
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return
data = urlparse.parse_qs(url)
data = dict((i, data[i][0]) for i in data)
title = data['title']
year = data['year']
tit = cleantitle.geturl(title + ' ' + year)
query = urlparse.urljoin(self.base_link, tit)
r = self.scraper.get(query, params={
'referer': self.base_link
}).content
if not data['imdb'] in r:
return sources
links = []
try:
down = client.parseDOM(r, 'div', attrs={'id':
'tab-download'})[0]
down = client.parseDOM(down, 'a', ret='href')[0]
data = client.request(down)
frames = client.parseDOM(data,
'div',
attrs={'class': 'single-link'})
frames = [
client.parseDOM(i, 'a', ret='href')[0] for i in frames if i
]
for i in frames:
links.append(i)
except Exception:
pass
try:
streams = client.parseDOM(r, 'div', attrs={'id':
'tab-stream'})[0]
streams = re.findall('''iframe src=(.+?) frameborder''',
streams.replace('"', ''),
re.I | re.DOTALL)
for i in streams:
links.append(i)
except Exception:
pass
for url in links:
try:
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
valid, host = source_utils.is_host_valid(
url, hostprDict)
if not valid:
continue
else:
rd = True
else:
rd = False
quality, info = source_utils.get_release_quality(url, url)
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
if rd:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': True
})
else:
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except Exception:
pass
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return sources
if debrid.status() is False: raise Exception()
hostDict = hostprDict + hostDict
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
ref_url = url = data['url']
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']
hdlr2 = 'season-%01d-episode-%01d' % (
int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else ''
imdb = data['imdb']
content = 'episode' if 'tvshowtitle' in data else 'movie'
season = data['season'] if 'season' in data else '0'
episode = data['episode'] if 'episode' in data else '0'
premiered = data['premiered'] if 'premiered' in data else '0'
_headers = {
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0'
}
r = client.request(url, headers=_headers)
posts = dom_parser.parse_dom(r, 'article',
{'class': ['post', 'excerpt']})
posts = [
(dom_parser.parse_dom(i, 'a', req=['href',
'title']), i.content)
for i in posts
if imdb in i.content or title.lower() in i.content.lower()
and hdlr.lower() in i.content.lower()
]
posts = [(i[0][0].attrs['title'], i[0][0].attrs['href'], i[1])
for i in posts]
items = []
for item in posts:
data = []
try:
name = item[0]
name = client.replaceHTMLCodes(name)
if content == 'episode':
if not hdlr2.lower() in item[1].lower():
if not premiered.replace('-', '').replace(
'+', '') in item[1].lower().replace(
'-', '').replace('+', ''):
raise Exception()
url = item[1]
r = client.request(url, headers=_headers)
data += client.parseDOM(r, 'div', attrs={'id': 'content'})
data += client.parseDOM(r, 'div', attrs={'id': 'comments'})
urls = dom_parser.parse_dom(data, 'a', req='href')
urls = [i.attrs['href'] for i in urls]
for url in urls:
try:
if any(x in url for x in
['.rar.', '.zip.', '.iso.']) or any(
url.endswith(x)
for x in ['.rar', '.zip', '.iso']):
raise Exception()
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(
url, hostDict)
if not valid: continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
quality, info = source_utils.get_release_quality(
url)
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 BaseException:
pass
info = ' | '.join(info)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except BaseException:
pass
except BaseException:
pass
return sources
except BaseException:
return sources
def _get_sources(self, url):
try:
item = client.request(url[0])
if item is None:
return
name = url[1]
self.title = self.title.replace('!', '')
# some shows like "Power" have year and hdlr in name
t = name.split(self.hdlr)[0].replace(self.year, '').replace(
'(', '').replace(')', '').replace('&', 'and')
tc = cleantitle.get(t)
if tc != cleantitle.get(self.title):
try:
if tc == self.aliases[0]:
pass
else:
return
except:
return
if self.hdlr not in name:
return
links = dom_parser.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:
pass
info = ' | '.join(info)
for url in links:
if any(x in url.lower()
for x in ['.rar.', '.zip.', '.iso.']) or any(
url.lower().endswith(x)
for x in ['.rar', '.zip', '.iso']):
continue
if any(x in url.lower()
for x in ['youtube', 'sample', 'trailer']):
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, info2 = source_utils.get_release_quality(name, 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:
source_utils.scraper_error('ONLINESERIES')
pass
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])
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 = client.request(url)
posts = client.parseDOM(html, 'item')
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
t = client.parseDOM(post, 'title')[0]
u = client.parseDOM(post, 'a', ret='href')
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']):
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
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'])
mozhdr = {
'User-Agent':
'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3'
}
headers = mozhdr
headers['X-Requested-With'] = 'XMLHttpRequest'
if 'tvshowtitle' in data:
episode = int(data['episode'])
url = self.searchShow(data['tvshowtitle'], data['season'],
aliases, headers)
else:
episode = 0
url = self.searchMovie(data['title'], data['year'], aliases,
headers)
headers['Referer'] = url
ref_url = url
mid = re.findall('-(\d*)\.', url)[0]
data = {'id': mid}
r = self.scraper.post(url, headers=headers).content
try:
u = urlparse.urljoin(self.base_link, self.server_link % mid)
r = self.scraper.get(u, headers=mozhdr).content
r = json.loads(r)['html']
rl = client.parseDOM(r, 'div', attrs={'class': 'pas-list'})
rh = client.parseDOM(r, 'div', attrs={'class': 'pas-header'})
ids = client.parseDOM(rl, 'li', ret='data-id')
servers = client.parseDOM(rl, 'li', ret='data-server')
labels = client.parseDOM(rl, 'a', ret='title')
r = zip(ids, servers, labels)
rrr = zip(client.parseDOM(rh, 'li', ret='data-id'),
client.parseDOM(rh, 'li', ret='class'))
types = {}
for rr in rrr:
types[rr[0]] = rr[1]
for eid in r:
try:
try:
ep = re.findall('episode.*?(\d+).*?',
eid[2].lower())[0]
except:
ep = 0
if (episode == 0) or (int(ep) == episode):
t = str(int(time.time() * 1000))
quali = source_utils.get_release_quality(eid[2])[0]
if 'embed' in types[eid[1]]:
url = urlparse.urljoin(
self.base_link, self.embed_link % (eid[0]))
xml = self.scraperget(url,
headers=headers).content
url = json.loads(xml)['src']
valid, hoster = source_utils.is_host_valid(
url, hostDict)
if not valid: continue
q = source_utils.check_sd_url(url)
q = q if q != 'SD' else quali
sources.append({
'source': hoster,
'quality': q,
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
continue
else:
url = urlparse.urljoin(
self.base_link,
self.token_link % (eid[0], mid, t))
script = self.scraper.get(url,
headers=headers).content
if '$_$' in script:
params = self.uncensored1(script)
elif script.startswith('[]') and script.endswith(
'()'):
params = self.uncensored2(script)
elif '_x=' in script:
x = re.search('''_x=['"]([^"']+)''',
script).group(1)
y = re.search('''_y=['"]([^"']+)''',
script).group(1)
params = {'x': x, 'y': y}
else:
raise Exception()
u = urlparse.urljoin(
self.base_link, self.source_link %
(eid[0], params['x'], params['y']))
length = 0
count = 0
while length == 0 and count < 11:
r = self.scraper.get(u,
headers=headers).content
length = len(r)
if length == 0:
count += 1
uri = None
uri = json.loads(r)['playlist'][0]['sources']
try:
uri = [i['file'] for i in uri if 'file' in i]
except:
try:
uri = [uri['file']]
except:
continue
for url in uri:
if 'googleapis' in url:
q = source_utils.check_sd_url(url)
sources.append({
'source': 'gvideo',
'quality': q,
'language': 'en',
'url': url,
'direct': True,
'debridonly': False
})
continue
valid, hoster = source_utils.is_host_valid(
url, hostDict)
# urls, host, direct = source_utils.check_directstreams(url, hoster)
q = quali
if valid:
# for z in urls:
if hoster == 'gvideo':
direct = True
try:
q = directstream.googletag(
url)[0]['quality']
except:
pass
url = directstream.google(url,
ref=ref_url)
else:
direct = False
sources.append({
'source': hoster,
'quality': q,
'language': 'en',
'url': url,
'direct': direct,
'debridonly': False
})
else:
sources.append({
'source': 'CDN',
'quality': q,
'language': 'en',
'url': url,
'direct': True,
'debridonly': False
})
except:
pass
except:
pass
return sources
except:
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])
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, "h2")
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)
r = self.scraper.get(i).content
u = client.parseDOM(r,
"div",
attrs={"class": "entry-content"})
for t in u:
r = re.compile('a href="(.+?)">.+?<').findall(t)
query = query.replace(' ', '.')
for url in r:
if not query in url:
continue
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):
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
