def _get_sources(self, item):
try:
name = item[0]
quality, info = source_utils.get_release_quality(name, item[1])
info.insert(0, item[2])
data = cfScraper.get(item[1]).content
data = ensure_text(data, errors='replace')
data = client.parseDOM(data, 'a', ret='href')
url = [i for i in data if 'magnet:' in i][0]
url = url.split('&tr')[0]
info = ' | '.join(info)
self._sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': item[3],
'name': name
})
except:
log_utils.log('1337x_exc1', 1)
pass
def _get_sources(self, name, url):
try:
headers = {'User-Agent': client.agent()}
r = cfScraper.get(url, headers=headers).content
r = ensure_text(r, errors='replace')
name = client.replaceHTMLCodes(name)
try:
_name = name.lower().replace('rr',
'').replace('nf', '').replace(
'ul', '').replace('cu', '')
except:
_name = name
l = dom_parser2.parse_dom(r, 'pre', {'class': 'links'})
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 not i.endswith(('.rar', '.zip', '.iso',
'.idx', '.sub', '.srt'))
]
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]
dsize, isize = source_utils._size(size)
except BaseException:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
self.sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize,
'name': _name
})
except:
log_utils.log('RMZ - Exception', 1)
pass
def sources(self, url, hostDict, hostprDict):
self.sources = []
try:
if url is None:
return self.sources
if debrid.status() is False:
return self.sources
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 = cleantitle.get_query(title)
hdlr = data['year']
hdlr2 = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else ''
imdb = data['imdb']
url = self.search(title, hdlr)
headers = {'User-Agent': client.agent()}
r = cfScraper.get(url, headers=headers).content
r = ensure_text(r, errors='replace')
if hdlr2 == '':
r = dom_parser2.parse_dom(r, 'ul', {'id': 'releases'})[0]
else:
r = dom_parser2.parse_dom(r, 'ul', {'id': 'episodes'})[0]
r = dom_parser2.parse_dom(r.content, 'a', req=['href'])
r = [(i.content, urljoin(self.base_link, i.attrs['href']))
for i in r if i and i.content != 'Watch']
if hdlr2 != '':
r = [(i[0], i[1]) for i in r if hdlr2.lower() in i[0].lower()]
self.hostDict = hostDict + hostprDict
threads = []
for i in r:
threads.append(workers.Thread(self._get_sources, i[0], i[1]))
[i.start() for i in threads]
alive = [x for x in threads if x.is_alive() is True]
while alive:
alive = [x for x in threads if x.is_alive() is True]
time.sleep(0.1)
return self.sources
except:
log_utils.log('RMZ - Exception', 1)
return self.sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
self.hostDict = hostDict + hostprDict
if url is None:
return sources
if debrid.status() is False: return
data = parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
self.title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = cleantitle.get_query(self.title)
self.hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (self.title, int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (self.title, data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.tvsearch.format(quote(query))
url = urljoin(self.base_link, url)
else:
url = self.moviesearch.format(quote(query))
url = urljoin(self.base_link, url)
r = cfScraper.get(url).content
r = ensure_text(r, errors='ignore')
posts = client.parseDOM(r, 'table', attrs={'class': 'table2'})[0]
posts = client.parseDOM(posts, 'tr')
for post in posts:
link = client.parseDOM(post, 'a', ret='href')[0]
hash = re.findall(r'(\w{40})', link, re.I)
if hash:
url = 'magnet:?xt=urn:btih:' + hash[0]
name = link.split('title=')[1]
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:
y = re.findall('[\.|\(|\[|\s\_|\-](\d{4})[\.|\)|\]|\s\_|\-]', name, re.I)[-1].upper()
if not y == self.hdlr: continue
quality, info = source_utils.get_release_quality(name, name)
try:
size = re.findall('((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))', post)[0]
dsize, isize = source_utils._size(size)
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
sources.append({'source': 'Torrent', 'quality': quality, 'language': 'en', 'url': url, 'info': info, 'direct': False,
'debridonly': True, 'size': dsize, 'name': name})
return sources
except:
log_utils.log('lime0 - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
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']
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']))
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url).replace('+', '-')
r = cfScraper.get(url).content
r = ensure_text(r, errors='ignore')
try:
data = re.compile(
'<a href="(.+?)" target="_blank" rel="nofollow" title.+?'
).findall(r)
for url in data:
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,
'direct': False,
'debridonly': False
})
except:
log_utils.log('projectfree2 - Exception', 1)
pass
return sources
except:
log_utils.log('projectfree3 - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: return sources
if debrid.status() is False: raise Exception()
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 = cleantitle.get_query(title)
query = '%s S%02dE%02d' % (title, int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else '%s' % data['imdb']
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
token = cfScraper.get(self.token).content
token = json.loads(token)["token"]
if 'tvshowtitle' in data:
search_link = self.tvsearch.format(token, quote_plus(query), 'format=json_extended')
else:
search_link = self.msearch.format(token, data['imdb'], 'format=json_extended')
control.sleep(250)
rjson = cfScraper.get(search_link).content
rjson = ensure_text(rjson, errors='ignore')
files = json.loads(rjson)['torrent_results']
for file in files:
name = file["title"]
url = file["download"]
url = url.split('&tr')[0]
quality, info = source_utils.get_release_quality(name, url)
try:
dsize = float(file["size"]) / 1073741824
isize = '%.2f GB' % dsize
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
sources.append({'source': 'Torrent', 'quality': quality, 'language': 'en', 'url': url, 'info': info, 'direct': False, 'debridonly': True, 'size': dsize, 'name': name})
return sources
except:
log_utils.log('torapi - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None: return sources
data = 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 == None:
url = self.searchShow(data['tvshowtitle'], data['season'], aliases)
else:
url = self.searchMovie(data['title'], data['year'], aliases)
if url == None: raise Exception()
r = cfScraper.get(url).content
r = ensure_text(r, errors='ignore')
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:
if link.startswith('//'):
link = 'https:' + link
host = re.findall('([\w]+[.][\w]+)$', urlparse(link.strip().lower()).netloc)[0]
if not host in hostDict: raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
if 'load.php' not in link:
sources.append({'source': host, 'quality': '720p', 'language': 'en', 'url': link, 'direct': False, 'debridonly': False})
except:
pass
return sources
except:
log_utils.log('123movies0 exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None:
return sources
hostDict = hostDict + hostprDict
sourcePage = ensure_text(cfScraper.get(url).content,
errors='replace')
thesources = re.compile('<tbody>(.+?)</tbody>',
re.DOTALL).findall(sourcePage)[0]
links = re.compile(
"<a href=\'(.+?)\' target=\'_blank\'>Download</a>",
re.DOTALL).findall(thesources)
for link in links:
linkPage = ensure_text(cfScraper.get(link).content,
errors='replace')
vlink = re.compile(
'<a id="link" rel="nofollow" href="(.+?)" class="btn"',
re.DOTALL).findall(linkPage)
for zlink in vlink:
valid, host = source_utils.is_host_valid(zlink, hostDict)
if valid:
quality, info = source_utils.get_release_quality(
zlink, zlink)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': zlink,
'info': info,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def __get_base_url(self, fallback):
try:
for domain in self.domains:
try:
url = 'https://%s' % domain
#result = client.request(url, limit=1, timeout='5')
result = cfScraper.get(url, timeout=4).content
result = ensure_text(result, errors='ignore')
search_n = re.findall('<title>(.+?)</title>', result, re.DOTALL)[0]
if result and 'LimeTorrents' in search_n:
return url
except:
pass
except:
pass
return fallback
def searchShow(self, title, season, aliases):
try:
#title = cleantitle.normalize(title)
search = '%s Season %01d' % (title, int(season))
url = urljoin(self.base_link, self.search_link % cleantitle.geturl(search))
r = cfScraper.get(url).content
r = ensure_text(r, errors='ignore')
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 = urljoin(self.base_link, '%s/watching.html' % url)
return url
except:
log_utils.log('123movies1 exception', 1)
return
def __get_base_url(self, fallback):
try:
for domain in self.domains:
try:
url = 'https://%s' % domain
result = cfScraper.get(url, timeout=7).content
result = ensure_text(result, errors='ignore')
search_n = re.findall('<title>(.+?)</title>', result,
re.DOTALL)[0]
if result and '1337x' in search_n:
return url
except Exception:
pass
except Exception:
pass
return fallback
def search(self, title, year):
try:
url = urljoin(self.base_link,
self.search_link % (quote_plus(title)))
headers = {'User-Agent': client.agent()}
r = cfScraper.get(url, headers=headers).content
r = ensure_text(r, errors='replace')
r = dom_parser2.parse_dom(r, 'div', {'class': 'list_items'})[0]
r = dom_parser2.parse_dom(r.content, 'li')
r = [(dom_parser2.parse_dom(i, 'a', {'class': 'title'}))
for i in r]
r = [(i[0].attrs['href'], i[0].content) for i in r]
r = [(urljoin(self.base_link, i[0])) for i in r
if cleantitle.get(title) in cleantitle.get(i[1])
and year in i[1]]
if r: return r[0]
else: return
except:
log_utils.log('RMZ - Exception', 1)
return
def _get_items(self, url):
try:
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
posts = client.parseDOM(r, 'tbody')[0]
posts = client.parseDOM(posts, 'tr')
for post in posts:
data = dom.parse_dom(post, 'a', req='href')[1]
link = urljoin(self.base_link, data.attrs['href'])
name = data.content
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]
dsize, isize = source_utils._size(size)
except BaseException:
dsize, isize = 0.0, ''
self.items.append((name, link, isize, dsize))
return self.items
except:
log_utils.log('1337x_exc0', 1)
return self.items
def searchMovie(self, title, year, aliases):
try:
#title = cleantitle.normalize(title)
url = urljoin(self.base_link, self.search_link % cleantitle.geturl(title))
r = cfScraper.get(url).content
r = ensure_text(r, errors='ignore')
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 = urljoin(self.base_link, '%s/watching.html' % url)
return url
except:
log_utils.log('123movies2 exception', 1)
return
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None:
return sources
if debrid.status() is False:
return sources
data = 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'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = urljoin(self.base_link, self.search_link % quote_plus(query))
r = ensure_str(cfScraper.get(url).content, errors='replace')
#log_utils.log('ultrahd_r ' + str(r))
r = client.parseDOM(r, 'div', attrs={'class': 'box-out margin'})
r = [(dom_parser.parse_dom(i, 'div', attrs={'class':'news-title'})) for i in r if data['imdb'] in i]
r = [(dom_parser.parse_dom(i[0], 'a', req='href')) for i in r if i]
r = [(i[0].attrs['href'], i[0].content) for i in r if i]
hostDict = hostprDict + hostDict
for item in r:
try:
data = ensure_text(cfScraper.get(item[0]).content, errors='replace')
data = client.parseDOM(data, 'div', attrs={'id': 'r-content'})[0]
urls = re.findall(r'\s*<u><a href="(.+?)".+?</a></u>', data, re.S)
try: details = client.parseDOM(data, 'div', attrs={'class': 'text_spoiler'})[0]
except: details = None
if details:
_zip = zip([u for u in urls if u.startswith('https://turbobit')], re.findall(r'General : (.+?)<br', details), re.findall(r'Length : (.+?) for', details))
else:
_zip = zip([u for u in urls if u.startswith('https://turbobit')], re.findall(r'/uploads/0-0-vip-(.+?).jpg', data, re.I|re.S))
for z in _zip:
try:
url = ensure_str(client.replaceHTMLCodes(z[0]))
name = ensure_str(client.replaceHTMLCodes(z[1])).replace('dual', ' dual ')
if 'dublaj' in name.lower(): continue
info = []
quality, info = source_utils.get_release_quality(url, name)
if quality == 'sd' and 'remux' in name.lower(): quality = '1080p'
try:
size = re.findall('((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))', z[2])[0]
dsize, isize = source_utils._size(size)
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
# if not 'turbobit' in url:
# continue
sources.append({'source': 'turbobit', 'quality': quality, 'language': 'en', 'url': url, 'info': info, 'size': dsize, 'name': name, 'direct': True, 'debridonly': True})
except:
log_utils.log('ultrahd_exc2', 1)
pass
except:
log_utils.log('ultrahd_exc1', 1)
pass
return sources
except:
log_utils.log('ultrahd_exc0', 1)
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 = cleantitle.get_query(title)
query = '%s S%02dE%02d' % (
title, int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else '%s %s' % (title, data['year'])
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url).replace('%3A+', '+')
#r = client.request(url)
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
posts = client.parseDOM(r, "div", attrs={"class": "postContent"})
items = []
for post in posts:
try:
p = client.parseDOM(post, "p", attrs={"dir": "ltr"})[1:]
for i in p:
items.append(i)
except:
pass
try:
for item in items:
u = client.parseDOM(item, 'a', ret='href')
name = re.findall('<strong>(.*?)</strong>', item,
re.DOTALL)[0]
name = client.replaceHTMLCodes(name)
t = re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*|3D)(\.|\)|\]|\s|)(.+|)',
'', name)
if not cleantitle.get(t) == cleantitle.get(title): continue
for url in u:
if any(x in url for x in ['.rar', '.zip', '.iso']):
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|gb|mb))',
item, re.DOTALL)[0]
dsize, isize = source_utils._size(size)
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
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,
'size': dsize,
'name': name
})
except:
pass
return sources
except:
log_utils.log('max_rls Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
raise Exception()
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 = cleantitle.get_query(title)
hdlr = 's%02de%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s s%02de%02d' % (
title, int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else '%s %s' % (title, data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
try:
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
posts = client.parseDOM(r, 'div', attrs={'class': 'post'})
items = []
for post in posts:
try:
u = client.parseDOM(post,
"div",
attrs={"class": "postContent"})
size = re.findall(
'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))',
u[0])[0]
u = client.parseDOM(u, "h2")
u = client.parseDOM(u, 'a', ret='href')
u = [(i.strip('/').split('/')[-1], i, size) for i in u]
items += u
except:
pass
except:
pass
for item in items:
try:
name = item[0]
name = client.replaceHTMLCodes(name)
t = re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*|3D)(\.|\)|\]|\s|)(.+|)',
'', name)
if not cleantitle.get(t) == cleantitle.get(title): continue
quality, info = source_utils.get_release_quality(
name, item[1])
try:
dsize, isize = source_utils._size(item[2])
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
url = item[1]
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
url = client.replaceHTMLCodes(url)
url = ensure_text(url)
host = re.findall('([\w]+[.][\w]+)$',
urlparse(url.strip().lower()).netloc)[0]
if host not in hostDict:
raise Exception()
host = client.replaceHTMLCodes(host)
host = ensure_text(host)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize,
'name': name
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if debrid.status() is False:
return sources
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])
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(u'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ',
query).lower()
url = urljoin(self.base_link, self.search_link % quote_plus(query))
#r = client.request(url)
#r = requests.get(url).content
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace').replace(' ', ' ')
r = client.parseDOM(
r,
'div',
attrs={'style': 'display:table;width:100%;text-align:left'})
posts = client.parseDOM(r, 'div', attrs={'class': 'one_result'})
#log_utils.log('posts_is: '+str(posts))
for post in posts:
links = client.parseDOM(post,
'div',
attrs={'class': 'fa fa-magnet'})[0]
url = client.parseDOM(links, 'a', ret='href')[0]
url = client.replaceHTMLCodes(url).split('&tr=')[0]
name = url.split('&dn=')[1]
if not query in cleantitle.get_title(name): continue
quality, info = source_utils.get_release_quality(name, url)
try:
size = client.parseDOM(post,
'span',
attrs={'class': 'torrent_size'})[0]
dsize, isize = source_utils._size(size)
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize,
'name': name
})
return sources
except:
log_utils.log('btdig3 - Exception', 1)
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']
year = data['year']
title = cleantitle.get_query(title)
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else year
premDate = ''
query = '%s S%02dE%02d' % (
title, int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else '%s %s' % (title, year)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
query = query.replace(" ", "-")
_base_link = self.base_link if int(
year) >= 2021 else self.old_base_link
#url = self.search_link % quote_plus(query)
#url = urljoin(_base_link, url)
url = _base_link + query
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
if r is None and 'tvshowtitle' in data:
season = re.search('S(.*?)E', hdlr)
season = season.group(1)
query = title
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
query = query + "-S" + season
query = query.replace("&", "and")
query = query.replace(" ", " ")
query = query.replace(" ", "-")
url = _base_link + query
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
for loopCount in list(range(0, 2)):
if loopCount == 1 or (r is None and 'tvshowtitle' in data):
#premDate = re.sub('[ \.]', '-', data['premiered'])
query = re.sub(r'[\\\\:;*?"<>|/\-\']', '', title)
query = query.replace("&", " and ").replace(
" ", " ").replace(
" ",
"-") # throw in extra spaces around & just in case
#query = query + "-" + premDate
url = _base_link + query
url = url.replace('The-Late-Show-with-Stephen-Colbert',
'Stephen-Colbert')
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace')
posts = client.parseDOM(r, "div", attrs={"class": "content"})
#hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
u = client.parseDOM(post, 'a', ret='href')
for i in u:
try:
name = str(i)
if hdlr in name.upper():
items.append(name)
#elif len(premDate) > 0 and premDate in name.replace(".", "-"):
#items.append(name)
except:
log_utils.log('RLSBB - Exception', 1)
pass
except:
log_utils.log('RLSBB - Exception', 1)
pass
if len(items) > 0:
break
seen_urls = set()
for item in items:
try:
info = []
url = str(item)
url = client.replaceHTMLCodes(url)
url = ensure_text(url)
if url in seen_urls:
continue
seen_urls.add(url)
host = url.replace("\\", "")
host2 = host.strip('"')
host = re.findall('([\w]+[.][\w]+)$',
urlparse(
host2.strip().lower()).netloc)[0]
if host not in hostDict:
continue
if any(x in host2
for x in ['.rar', '.zip', '.iso', '.part']):
continue
quality, info = source_utils.get_release_quality(host2)
#try:
# size = re.findall('((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))', post)[0]
# div = 1 if size.endswith(('GB', 'GiB')) else 1024
# size = float(re.sub('[^0-9|/.|/,]', '', size.replace(',', '.'))) / div
# size = '%.2f GB' % size
# info.append(size)
#except:
# pass
info = ' | '.join(info)
host = client.replaceHTMLCodes(host)
host = ensure_text(host)
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': host2,
'info': info,
'direct': False,
'debridonly': True
})
except:
log_utils.log('RLSBB - Exception', 1)
pass
check = [i for i in sources if not i['quality'] == 'CAM']
if check:
sources = check
return sources
except:
log_utils.log('RLSBB - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if debrid.status() is False:
return sources
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])
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(u'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ',
query).lower()
url = urljoin(self.base_link, self.search_link % query)
#r = client.request(url)
#r = requests.get(url).content
r = cfScraper.get(url).content
r = ensure_text(r, errors='replace').replace(' ', ' ')
r = client.parseDOM(r, 'div', attrs={'class': 'col s12'})
posts = client.parseDOM(r, 'div')[1:]
posts = [i for i in posts if 'magnet/' in i]
for post in posts:
links = client.parseDOM(post, 'a', ret='href')[0]
url = 'magnet:?xt=urn:btih:' + links.lstrip('magnet/')
try:
name = client.parseDOM(post, 'a', ret='title')[0]
if not query in cleantitle.get_title(name): continue
except:
name = ''
quality, info = source_utils.get_release_quality(name, name)
try:
size = re.findall(r'<b class="cpill .+?-pill">(.+?)</b>',
post)[0]
dsize, isize = source_utils._size(size)
except:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
sources.append({
'source': 'Torrent',
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize,
'name': name
})
return sources
except:
log_utils.log('bt4g3 - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None: 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 = cleantitle.get_query(title)
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s season %d' % (title, int(data['season'])) if 'tvshowtitle' in data else title
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
query = quote_plus(query)
url = urljoin(self.base_link, self.search_link % query)
ua = {'User-Agent': client.agent()}
r = cfScraper.get(url, headers=ua).content
r = six.ensure_text(r, errors='replace')
_posts = client.parseDOM(r, 'div', attrs={'class': 'item'})
posts = []
for p in _posts:
try:
post = (client.parseDOM(p, 'a', ret='href')[1],
client.parseDOM(p, 'a')[1],
re.findall(r'Release:\s*?(\d{4})</', p, re.I|re.S)[1])
posts.append(post)
except:
pass
posts = [(i[0], client.parseDOM(i[1], 'i')[0], i[2]) for i in posts if i]
if 'tvshowtitle' in data:
sep = 'season %d' % int(data['season'])
sepi = 'season-%1d/episode-%1d.html' % (int(data['season']), int(data['episode']))
post = [i[0] for i in posts if sep in i[1].lower()][0]
data = cfScraper.get(post, headers=ua).content
data = six.ensure_text(data, errors='replace')
link = client.parseDOM(data, 'a', ret='href')
link = [i for i in link if sepi in i][0]
else:
link = [i[0] for i in posts if cleantitle.get_title(title) in cleantitle.get_title(i[1]) and hdlr == i[2]][0]
r = cfScraper.get(link, headers=ua).content
r = six.ensure_text(r, errors='replace')
try:
v = re.findall('document.write\(Base64.decode\("(.+?)"\)', r)[0]
v = v.encode('utf-8')
b64 = base64.b64decode(v)
b64 = six.ensure_text(b64, errors='ignore')
url = client.parseDOM(b64, 'iframe', ret='src')[0]
try:
host = re.findall('([\w]+[.][\w]+)$', urlparse(url.strip().lower()).netloc)[0]
host = client.replaceHTMLCodes(host)
host = six.ensure_str(host)
valid, hoster = source_utils.is_host_valid(host, hostDict)
if valid:
sources.append({
'source': hoster,
'quality': 'SD',
'language': 'en',
'url': url.replace('\/', '/'),
'direct': False,
'debridonly': False
})
except:
log_utils.log('plockers4 Exception', 1)
pass
except:
log_utils.log('plockers3 Exception', 1)
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].replace('\/', '/')
host = client.replaceHTMLCodes(host)
host = six.ensure_str(host)
if 'other' in host: continue
valid, hoster = source_utils.is_host_valid(host, hostDict)
if valid:
sources.append({
'source': hoster,
'quality': 'SD',
'language': 'en',
'url': url,
'direct': False,
'debridonly': False
})
except:
log_utils.log('plockers5 Exception', 1)
pass
return sources
except:
log_utils.log('plockers Exception', 1)
return