def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if url == None: return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['premiered'], url['season'], url[
'episode'] = premiered, season, episode
try:
clean_title = cleantitle.geturl(
url['tvshowtitle']) + '-season-%d' % int(season)
search_url = urlparse.urljoin(
self.base_link,
self.search_link % clean_title.replace('-', '+'))
r = client.request(search_url)
r = client.parseDOM(r, 'div', {'class': 'item'})
r = [(client.parseDOM(i, 'a', ret='href'),
re.findall('<b><i>(.+?)</i>', i)) for i in r]
r = [(i[0][0], i[1][0]) for i in r
if cleantitle.get(i[1][0]) == cleantitle.get(clean_title)]
url = r[0][0]
except:
pass
data = self.scraper.get(url).content
data = client.parseDOM(data, 'div', attrs={'id': 'details'})
data = zip(client.parseDOM(data, 'a'),
client.parseDOM(data, 'a', ret='href'))
url = [(i[0], i[1]) for i in data if i[0] == str(int(episode))]
return url[0][1]
except:
return
def links(self, url):
urls = []
try:
if url is None: return
r = client.request(url)
r = client.parseDOM(r, 'div', attrs={'class': 'entry'})
r = client.parseDOM(r, 'a', ret='href')
r1 = [(i) for i in r if 'money' in i][0]
r = client.request(r1)
r = client.parseDOM(r, 'div', attrs={'id': 'post-\d+'})[0]
if 'enter the password' in r:
plink = client.parseDOM(r, 'form', ret='action')[0]
post = {'post_password': '******', 'Submit': 'Submit'}
send_post = client.request(plink, post=post, output='cookie')
link = client.request(r1, cookie=send_post)
else:
link = client.request(r1)
link = re.findall('<strong>Single(.+?)</tr', link, re.DOTALL)[0]
link = client.parseDOM(link, 'a', ret='href')
link = [(i.split('=')[-1]) for i in link]
for i in link:
urls.append(i)
return urls
except:
pass
def sources(self, url, hostDict, hostprDict):
try:
sources = []
url = url + 'watch/'
r = client.request(url)
qual = re.compile('class="quality">(.+?)<').findall(r)
for i in qual:
if 'HD' in i:
quality = '720p'
else:
quality = 'SD'
r = client.parseDOM(r, "div", attrs={"id": "list-eps"})
for i in r:
t = re.compile('<a href="(.+?)"').findall(i)
for url in t:
t = self.scraper.get(url).content
t = client.parseDOM(t, "div", attrs={"id": "content-embed"})
for u in t:
i = re.findall('src="(.+?)"', u)[0].replace('load_player.html?e=', 'episode/embed/')
i = self.scraper.get(i).conent.replace("\\", "")
u = re.findall('"(https.+?)"', i)
for url in u:
sources.append(
{'source': 'CDN', 'quality': quality, 'language': 'en', 'url': url, 'direct': False,
'debridonly': False})
return sources
except Exception:
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)
html = client.request(url)
try:
results = client.parseDOM(html, 'div', attrs={'class': 'row'})[2]
except Exception:
return sources
items = re.findall('class="browse-movie-bottom">(.+?)</div>\s</div>', results, re.DOTALL)
if items is None:
return sources
for entry in items:
try:
try:
link, name = \
re.findall('<a href="(.+?)" class="browse-movie-title">(.+?)</a>', entry, re.DOTALL)[0]
name = client.replaceHTMLCodes(name)
if not cleantitle.get(name) == cleantitle.get(data['title']):
continue
except Exception:
continue
y = entry[-4:]
if not y == data['year']:
continue
response = client.request(link)
try:
entries = client.parseDOM(response, 'div', attrs={'class': 'modal-torrent'})
for torrent in entries:
link, name = re.findall(
'href="magnet:(.+?)" class="magnet-download download-torrent magnet" title="(.+?)"',
torrent, re.DOTALL)[0]
link = 'magnet:%s' % 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})
except Exception:
continue
except Exception:
continue
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
r = self.scraper.get(url).content
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.urlparse(url.strip().lower()).netloc)[0]
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url.replace('\/', '/'),
'direct': False,
'debridonly': True
})
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)
host = host.encode('utf-8')
if 'other' in host: continue
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url.replace('\/', '/'),
'direct': False,
'debridonly': True
})
except:
pass
return sources
except Exception:
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])
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):
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 resolve(self, url):
if self.base_link in url:
try:
r = self.scraper.get(url).content
v = re.findall('document.write\(Base64.decode\("(.+?)"\)',
r)[0]
b64 = base64.b64decode(v)
url = client.parseDOM(b64, 'iframe', ret='src')[0]
except:
r = self.scraper.get(url).content
r = client.parseDOM(r, 'div', attrs={'class': 'player'})
url = client.parseDOM(r, 'a', ret='href')[0]
return url
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])
title = data['tvshowtitle']
hdlr = 's%02de%02d' % (int(data['season']), int(data['episode']))
query = urllib.quote_plus(cleantitle.getsearch(title))
surl = urlparse.urljoin(self.base_link, self.search_link % query)
r = client.request(surl, XHR=True)
r = json.loads(r)
r = r['series']
for i in r:
tit = i['value']
if not cleantitle.get(title) == cleantitle.get(tit):
raise Exception()
slink = i['seo']
slink = urlparse.urljoin(self.base_link, slink)
r = client.request(slink)
if not data['imdb'] in r: raise Exception()
data = client.parseDOM(r, 'div', {'class': 'el-item\s*'})
epis = [
client.parseDOM(i, 'a', ret='href')[0] for i in data if i
]
epis = [i for i in epis if hdlr in i.lower()][0]
r = client.request(epis)
links = client.parseDOM(r, 'a', ret='data-actuallink')
for url in links:
try:
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid: raise Exception()
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except BaseException:
return sources
return sources
except BaseException:
return sources
def searchShow(self, title, season, aliases):
try:
title = cleantitle.normalize(title)
search = '%s Season %01d' % (title, int(season))
url = urlparse.urljoin(self.base_link, self.search_link % cleantitle.geturl(search))
r = self.scraper.get(url).content
r = client.parseDOM(r, 'div', attrs={'class': 'ml-item'})
r = zip(client.parseDOM(r, 'a', ret='href'), client.parseDOM(r, 'a', ret='title'))
r = [(i[0], i[1], re.findall('(.*?)\s+-\s+Season\s+(\d)', i[1])) for i in r]
r = [(i[0], i[1], i[2][0]) for i in r if len(i[2]) > 0]
url = [i[0] for i in r if self.matchAlias(i[2][0], aliases) and i[2][1] == season][0]
url = urlparse.urljoin(self.base_link, '%s/watching.html' % url)
return url
except:
return
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
try:
query = self.tvsearch_link % urllib.quote_plus(
cleantitle.query(tvshowtitle))
query = urlparse.urljoin(self.base_link, query.lower())
result = self.scraper.get(query).content
result = client.parseDOM(
result, 'div', attrs={
'class': 'index_item.+?'})
result = [(dom.parse_dom(i, 'a', req=['href', 'title'])[0])
for i in result if i]
result = [
(i.attrs['href']) for i in result if cleantitle.get(tvshowtitle) == cleantitle.get(
re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d+E\d+|S\d+|3D)(\.|\)|\]|\s|)(.+|)',
'',
i.attrs['title'],
flags=re.I))][0]
url = client.replaceHTMLCodes(result)
url = url.encode('utf-8')
return url
except Exception:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
queries = [url['title'], '%s-%s' % (url['title'], url['year'])]
r = requests.get('%s%s' %
(self.base_link, self.search_link % queries[0]))
if not r.ok:
r = requests.get(
'%s%s' % (self.base_link, self.search_link % queries[1]))
if not r.ok:
return
r = r.content
qual = re.compile('class="quality">(.+?)<').findall(r)
for i in qual:
quality = source_utils.check_direct_url(i)
u = client.parseDOM(r,
"div",
attrs={"class": "pa-main anime_muti_link"})
for t in u:
urls = re.findall('<li class=".+?" data-video="(.+?)"', t)
for url in urls:
if 'vidcloud' in url:
url = 'https:' + url
r = requests.get(url).content
t = re.findall(
'li data-status=".+?" data-video="(.+?)"', r)
for url in t:
if 'vidcloud' in url:
continue
valid, host = source_utils.is_host_valid(
url, hostDict)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
if 'vidcloud' in url:
continue
valid, host = source_utils.is_host_valid(url, hostDict)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
return sources
except:
import traceback
traceback.print_exc()
return
def resolve(self, url):
if self.base_link in url:
url = self.scraper.get(url).content
v = re.findall('document.write\(Base64.decode\("(.+?)"\)', url)[0]
b64 = base64.b64decode(v)
url = client.parseDOM(b64, 'iframe', ret='src')[0]
return url
def sources(self, url, hostDict, hostprDict):
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])
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 = self.scraper.get(url).content
if url == None:
url = self.searchShow(data['tvshowtitle'], data['season'], aliases)
else:
url = self.searchMovie(data['title'], data['year'], aliases)
if url == None: raise Exception()
r = self.scraper.get(url).content
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:
try:
host = re.findall('([\w]+[.][\w]+)$', urlparse.urlparse(link.strip().lower()).netloc)[0]
if not host in hostDict: raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({'source': host, 'quality': '720p', 'language': 'en', 'url': link, 'direct': False,
'debridonly': False})
except:
pass
return sources
except:
return sources
def searchMovie(self, title, year):
try:
query = self.search_link % urllib.quote_plus(
cleantitle.getsearch(title))
url = urlparse.urljoin(self.base_link, query)
r = client.request(url)
r = client.parseDOM(r, 'item')
r = [(client.parseDOM(i, 'title')[0], client.parseDOM(i,
'link')[0])
for i in r if i]
r = [
i[1] for i in r
if cleantitle.get(title) == cleantitle.get(i[0])
]
return r[0]
except Exception:
return
def resolve(self, url):
if 'hideurl' in url:
data = self.scraper.get(url).content
data = client.parseDOM(data, 'div', attrs={'class': 'row'})
url = [dom_parser2.parse_dom(i, 'a', req='href')[0] for i in data]
url = [i.attrs['href'] for i in url if 'direct me' in i.content][0]
return url
else:
return url
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
try:
q = cleantitle.query(tvshowtitle)
r = self.scraper.get(self.search_link % q,
headers={
'referer': self.base_link
}).content
r = client.parseDOM(r, 'div', attrs={'valign': '.+?'})
r = [(client.parseDOM(i, 'a', ret='href'),
client.parseDOM(i, 'a',
ret='title'), client.parseDOM(i, 'a'))
for i in r]
r = [(i[0][0], i[1][0], i[2][0]) for i in r
if i[0] and i[1] and i[2]]
return r[0][0]
except:
traceback.print_exc()
return
def _get_items(self, url):
try:
headers = {'User-Agent': client.agent()}
r = client.request(url, headers=headers)
posts = client.parseDOM(r,
'tr',
attrs={'id': 'torrent_latest_torrents'})
for post in posts:
data = client.parseDOM(post,
'a',
attrs={'title': 'Torrent magnet link'},
ret='href')[0]
link = urllib.unquote(data).decode('utf8').replace(
'https://mylink.me.uk/?url=', '')
name = urllib.unquote_plus(
re.search('dn=([^&]+)', link).groups()[0])
t = name.split(self.hdlr)[0]
if not cleantitle.get(re.sub('(|)', '', t)) == cleantitle.get(
self.title):
continue
try:
y = re.findall(
'[\.|\(|\[|\s|\_|\-](S\d+E\d+|S\d+)[\.|\)|\]|\s|\_|\-]',
name, re.I)[-1].upper()
except BaseException:
y = re.findall(
'[\.|\(|\[|\s\_|\-](\d{4})[\.|\)|\]|\s\_|\-]', name,
re.I)[-1].upper()
if not y == self.hdlr: continue
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') else 1024
size = float(
re.sub('[^0-9|/.|/,]', '', size.replace(',',
'.'))) / div
size = '%.2f GB' % size
except BaseException:
size = '0'
self.items.append((name, link, size))
return self.items
except BaseException:
return self.items
def movie(self, imdb, title, localtitle, aliases, year):
try:
clean_title = cleantitle.geturl(title)
search_url = urlparse.urljoin(
self.base_link,
self.search_link % clean_title.replace('-', '+'))
r = self.scraper.get(search_url).content
r = client.parseDOM(r, 'div', {'id': 'movie-featured'})
r = [(client.parseDOM(i, 'a', ret='href'),
re.findall('.+?elease:\s*(\d{4})</',
i), re.findall('<b><i>(.+?)</i>', i)) for i in r]
r = [(i[0][0], i[1][0], i[2][0]) for i in r
if (cleantitle.get(i[2][0]) == cleantitle.get(title)
and i[1][0] == year)]
url = r[0][0]
return url
except Exception:
return
def episodeAbsoluteNumber(self, thetvdb, season, episode):
try:
url = 'http://thetvdb.com/api/%s/series/%s/default/%01d/%01d' % (
'MUQ2MkYyRjkwMDMwQzQ0NA=='.decode('base64'), thetvdb,
int(season), int(episode))
return int(
client.parseDOM(client.request(url), 'absolute_number')[0])
except:
pass
return episode
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 = self.scraper.get(url).content
links = client.parseDOM(result, '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 Exception:
pass
return sources
except Exception:
return sources
def getTVShowTranslation(self, thetvdb, lang):
try:
url = 'http://thetvdb.com/api/%s/series/%s/%s.xml' % (
'MUQ2MkYyRjkwMDMwQzQ0NA=='.decode('base64'), thetvdb, lang)
r = client.request(url)
title = client.parseDOM(r, 'SeriesName')[0]
title = client.replaceHTMLCodes(title)
title = title.encode('utf-8')
return title
except:
pass
def searchMovie(self, title, year, aliases):
try:
title = cleantitle.normalize(title)
url = urlparse.urljoin(self.base_link, self.search_link % cleantitle.geturl(title))
r = self.scraper.get(url).content
r = client.parseDOM(r, 'div', attrs={'class': 'ml-item'})
r = zip(client.parseDOM(r, 'a', ret='href'), client.parseDOM(r, 'a', ret='title'))
results = [(i[0], i[1], re.findall('\((\d{4})', i[1])) for i in r]
try:
r = [(i[0], i[1], i[2][0]) for i in results if len(i[2]) > 0]
url = [i[0] for i in r if self.matchAlias(i[1], aliases) and (year == i[2])][0]
except:
url = None
pass
if (url == None):
url = [i[0] for i in results if self.matchAlias(i[1], aliases)][0]
url = urlparse.urljoin(self.base_link, '%s/watching.html' % url)
return url
except:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if url is None:
return
r = self.scraper.get(url, headers={
'referer': self.base_link
}).content
r = client.parseDOM(r, 'li', attrs={'itemprop': 'episode'})
t = cleantitle.get(title)
r = [(client.parseDOM(i, 'a', ret='href'),
client.parseDOM(i, 'span', attrs={'itemprop': 'name'}),
re.compile('(\d{4}-\d{2}-\d{2})').findall(i)) for i in r]
r = [(i[0], i[1][0].split(' ')[-1], i[2])
for i in r if i[1]] + [(i[0], None, i[2])
for i in r if not i[1]]
r = [(i[0], i[1], i[2][0])
for i in r if i[2]] + [(i[0], i[1], None)
for i in r if not i[2]]
r = [(i[0][0], i[1], i[2]) for i in r if i[0]]
url = [
i for i in r if t == cleantitle.get(i[1]) and premiered == i[2]
][:1]
if not url:
url = [i for i in r if t == cleantitle.get(i[1])]
if len(url) > 1 or not url:
url = [i for i in r if premiered == i[2]]
if len(url) > 1 or not url:
raise Exception()
return url[0][0]
except:
failure = traceback.format_exc()
log_utils.log('XWatchSeries - Exception: \n' + str(failure))
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if url == None: return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['premiered'], url['season'], url[
'episode'] = premiered, season, episode
try:
clean_title = cleantitle.geturl(
url['tvshowtitle']) + '-season-%d' % int(season)
search_url = urlparse.urljoin(
self.base_link,
self.search_link % clean_title.replace('-', '+'))
r = self.scraper.get(search_url).content
r = dom_parser2.parse_dom(r, 'li', {'class': 'item'})
r = [(dom_parser2.parse_dom(i, 'a', attrs={'class': 'title'}),
dom_parser2.parse_dom(i,
'div',
attrs={'class': 'status'})[0])
for i in r if i]
r = [(i[0][0].attrs['href'],
re.findall('(.+?)</b><br', i[0][0].content,
re.DOTALL)[0],
re.findall('(\d+)', i[1].content)[0]) for i in r if i]
r = [(i[0], i[1].split(':')[0], i[2]) for i in r
if (cleantitle.get(i[1].split(':')[0]) == cleantitle.get(
url['tvshowtitle']) and i[2] == str(int(season)))]
url = r[0][0]
except:
pass
data = self.scraper.get(url).content
data = client.parseDOM(data, 'div', attrs={'id': 'details'})
data = zip(client.parseDOM(data, 'a'),
client.parseDOM(data, 'a', ret='href'))
url = [(i[0], i[1]) for i in data if i[0] == str(int(episode))]
return url[0][1]
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])
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 movie(self, imdb, title, localtitle, aliases, year):
try:
title = cleantitle.geturl(title).replace('-', '+')
u = self.base_link + self.search_link % title
u = self.scraper.get(u).content
i = client.parseDOM(u, "div", attrs={"class": "movies-list"})
for r in i:
r = re.compile('<a href="(.+?)"').findall(r)
for url in r:
title = cleantitle.geturl(title).replace("+", "-")
if title not in url:
continue
return url
except:
return
def resolve(self, url):
try:
if '/stream/' in url or '/watch/' in url:
r = self.scraper.get(url, referer=self.base_link).content
link = client.parseDOM(r, 'a', ret='data-href', attrs={'id': 'iframe_play'})[0]
else:
data = self.scraper.get(url, referer=self.base_link).content
data = re.findall(
r'\s*(eval.+?)\s*</script', data, re.DOTALL)[0]
link = jsunpack.unpack(data)
link = link.replace('\\', '')
link = re.findall(r'''go\(['"](.+?)['"]\)''', link)[0]
return link
except Exception:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
r = self.scraper.get(url, headers={
'referer': self.base_link
}).content
links = client.parseDOM(r,
'a',
ret='href',
attrs={'target': '.+?'})
links = [x for y, x in enumerate(links) if x not in links[:y]]
for i in links:
try:
url = i
url = proxy.parse(url)
url = urlparse.parse_qs(
urlparse.urlparse(url).query)['r'][0]
url = url.decode('base64')
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(url.strip().lower()).netloc)[0]
if host not in hostDict:
continue
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
failure = traceback.format_exc()
log_utils.log('XWatchSeries - Exception: \n' + str(failure))
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 = self.scraper(url).content
try:
results = client.parseDOM(html, 'div', attrs={'class': 'ava1'})
except:
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:
return
