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])
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(r'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.search.format('8', quote(query))
else:
url = self.search.format('4', quote(query))
self.hostDict = hostDict + hostprDict
headers = {'User-Agent': client.agent()}
_html = client.request(url, headers=headers)
threads = []
for i in re.findall(r'<item>(.+?)</item>', _html, re.DOTALL):
threads.append(workers.Thread(self._get_items, i))
[i.start() for i in threads]
[i.join() for i in threads]
return self._sources
except BaseException:
return self._sources
def sources(self, url, hostDict, hostprDict):
self.sources = []
try:
scraper = cfscrape.create_scraper()
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])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.aliases = data['aliases']
self.episode_title = data[
'title'] if 'tvshowtitle' in data else None
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', query)
urls = []
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
urls.append(url)
# urls.append('%s%s' % (url, '&page=2')) # next page seems broken right now
# urls.append('%s%s' % (url, '&page=3'))
# log_utils.log('urls = %s' % urls, log_utils.LOGDEBUG)
links = []
for x in urls:
r = scraper.get(x).content
if not r:
continue
list = client.parseDOM(r, 'tr', attrs={'class': 'tlr'})
list += client.parseDOM(r, 'tr', attrs={'class': 'tlz'})
for item in list:
links.append(item)
threads = []
for link in links:
threads.append(workers.Thread(self.get_sources, link))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
source_utils.scraper_error('EXTRATORRENT')
return self.sources
def movie(self, imdb, title, localtitle, aliases, year):
if debrid.status() is False:
return
try:
url = {'imdb': imdb, 'title': title, 'year': year}
url = urllib.urlencode(url)
return url
except Exception:
return
def sources(self, url, hostDict, hostprDict):
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 movie(self, imdb, title, localtitle, aliases, year):
if debrid.status() is False:
return
try:
url = {'imdb': imdb, 'title': title, 'year': year}
url = urlencode(url)
return url
except:
log_utils.log('1337x - Exception', 1)
return
def movie(self, imdb, title, localtitle, aliases, year):
if debrid.status() is False:
return
try:
url = {'imdb': imdb, 'title': title, 'year': year}
url = urllib.urlencode(url)
return url
except Exception:
failure = traceback.format_exc()
log_utils.log('ZOOGLE - Exception: \n' + str(failure))
return
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):
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_packs(self,
url,
hostDict,
hostprDict,
search_series=False,
total_seasons=None,
bypass_filter=False):
self.sources = []
try:
self.search_series = search_series
self.total_seasons = total_seasons
self.bypass_filter = bypass_filter
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])
self.title = data['tvshowtitle'].replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.aliases = data['aliases']
self.imdb = data['imdb']
self.year = data['year']
self.season_x = data['season']
self.season_xx = self.season_x.zfill(2)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', self.title)
queries = [
self.search_link % quote_plus(query + ' S%s' % self.season_xx),
self.search_link %
quote_plus(query + ' Season %s' % self.season_x)
]
if search_series:
queries = [
self.search_link % quote_plus(query + ' Season'),
self.search_link % quote_plus(query + ' Complete')
]
threads = []
for url in queries:
link = urljoin(self.base_link, url)
threads.append(workers.Thread(self.get_sources_packs, link))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
source_utils.scraper_error('SKYTORRENTS')
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):
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])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.aliases = data['aliases']
self.episode_title = data[
'title'] if 'tvshowtitle' in data else None
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', query)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
try:
r = client.request(url, timeout='5')
if r is None:
return self.sources
links = re.findall('<a href=(/torrent/.+?)>', r, re.DOTALL)
threads = []
for link in links:
threads.append(workers.Thread(self.get_sources, link))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
source_utils.scraper_error('TORLOCK')
return self.sources
except:
source_utils.scraper_error('TORLOCK')
return self.sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
if debrid.status() is False:
raise Exception()
data = 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_plus(query))
url = urljoin(self.base_link, url)
else:
url = self.moviesearch.format(quote_plus(query))
url = urljoin(self.base_link, url)
items = self._get_items(url)
hostDict = hostDict + hostprDict
for item in items:
try:
name = item[0]
url = item[1]
url = url.split('&tr')[0]
quality, info = source_utils.get_release_quality(name, url)
info.insert(0, item[2])
info = ' | '.join(info)
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('glodls0_exc', 1)
pass
return sources
except:
log_utils.log('glodls1_exc', 1)
return sources
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
if debrid.status() is False:
return
try:
url = {
'imdb': imdb,
'tvdb': tvdb,
'tvshowtitle': tvshowtitle,
'year': year
}
url = urlencode(url)
return url
except Exception:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
if debrid.status() is False:
return
try:
if url is None:
return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['title'], url['premiered'], url['season'], url[
'episode'] = title, premiered, season, episode
url = urllib.urlencode(url)
return url
except Exception:
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%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else '%s' % data['imdb']
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
token = client.request(self.token)
token = json.loads(token)["token"]
if 'tvshowtitle' in data:
search_link = self.tvsearch.format(token,
urllib.quote_plus(query),
'format=json_extended')
else:
search_link = self.msearch.format(token, data['imdb'],
'format=json_extended')
rjson = client.request(search_link)
files = json.loads(rjson)['torrent_results']
for file in files:
name = file["title"]
url = file["download"]
url = url.split('&tr')[0]
quality, info = source_utils.get_release_quality(name, url)
dsize = float(file["size"]) / 1073741824
isize = '%.2f GB' % dsize
#size = source_utils.convert_size(file["size"])
#size = '[B]%s[/B]' % size
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
})
return sources
except BaseException:
return sources
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
if debrid.status() is False:
return
try:
if url is None:
return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['title'], url['premiered'], url['season'], url['episode'] = title, premiered, season, episode
url = urllib.urlencode(url)
return url
except Exception:
failure = traceback.format_exc()
log_utils.log('1337x - Exception: \n' + str(failure))
return
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 = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
try:
r = client.request(url)
links = re.findall('<a href="(/torrent/.+?)"', r, re.DOTALL)
threads = []
for link in links:
threads.append(workers.Thread(self.get_sources, link))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
return self.sources
except:
return self.sources
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])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace(
'Special Victims Unit', 'SVU')
self.aliases = data['aliases']
self.episode_title = data[
'title'] if 'tvshowtitle' in data else None
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', query)
urls = []
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
urls.append(url)
# urls.append(url.replace('page=0', 'page=40')) # server response time WAY to slow to parse 2 pages deep, site sucks.
# log_utils.log('urls = %s' % urls, log_utils.LOGDEBUG)
threads = []
for url in urls:
threads.append(workers.Thread(self.get_sources, url))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
source_utils.scraper_error('ISOHUNT2')
return self.sources
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])
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']
self.hdlr = self.hdlr.lower()
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', query)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url).replace('+', '-')
try:
r = client.request(url)
links = re.findall('<a href="(/torrent/.+?)"', r, re.DOTALL)[:20]
threads = []
for link in links:
threads.append(workers.Thread(self.get_sources, link))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
log_utils.log('YourBT3 - Exception', 1)
return self.sources
except:
log_utils.log('YourBT3 - Exception', 1)
return self.sources
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])
self.title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.title = self.title.replace('&', 'and').replace('Special Victims Unit', 'SVU')
self.aliases = data['aliases']
self.episode_title = data['title'] if 'tvshowtitle' in data else None
self.hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
self.year = data['year']
query = '%s %s' % (self.title, self.hdlr)
query = re.sub('[^A-Za-z0-9\s\.-]+', '', query)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
if not r:
return self.sources
rows = client.parseDOM(r, 'div', attrs={'id': 'profile1'})
threads = []
for row in rows:
threads.append(workers.Thread(self.get_sources, row))
[i.start() for i in threads]
[i.join() for i in threads]
return self.sources
except:
source_utils.scraper_error('MAGNET4YOU')
return self.sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
self.items = []
if url is None:
return self._sources
if debrid.status() is False: return
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
self.title = data[
'tvshowtitle'] if 'tvshowtitle' in data else data['title']
self.hdlr = 'S%02dE%02d' % (
int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
if 'tvshowtitle' in data:
url = self.tvsearch.format(urllib.quote(query))
url = urlparse.urljoin(self.base_link, url)
else:
url = self.moviesearch.format(urllib.quote(query))
url = urlparse.urljoin(self.base_link, url)
self._get_items(url)
self.hostDict = hostDict + hostprDict
threads = []
for i in self.items:
threads.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads]
[i.join() for i in threads]
return self._sources
except BaseException:
return self._sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is 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])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data[
'title']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
aliases = data['aliases']
episode_title = data['title'] if 'tvshowtitle' in data else None
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('[^A-Za-z0-9\s\.-]+', '', query)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
r = client.request(url)
if '<tbody' not in r:
return sources
posts = client.parseDOM(r, 'tbody')[0]
posts = client.parseDOM(posts, 'tr')
except:
source_utils.scraper_error('SKYTORRENTS')
return sources
for post in posts:
try:
post = re.sub(r'\n', '', post)
post = re.sub(r'\t', '', post)
link = re.findall(
'href="(magnet:.+?)".+<td style="text-align: center;color:green;">([0-9]+|[0-9]+,[0-9]+)</td>',
post, re.DOTALL)
for url, seeders, in link:
url = unquote_plus(url).split('&tr')[0].replace(
'&', '&').replace(' ', '.')
url = source_utils.strip_non_ascii_and_unprintable(url)
if url in str(self.sources):
return
hash = re.compile('btih:(.*?)&').findall(url)[0]
name = url.split('&dn=')[1]
name = source_utils.clean_name(title, name)
if source_utils.remove_lang(name, episode_title):
continue
if not source_utils.check_title(title, aliases, name, hdlr,
data['year']):
continue
# filter for episode multi packs (ex. S01E01-E17 is also returned in query)
if episode_title:
if not source_utils.filter_single_episodes(hdlr, name):
continue
try:
seeders = int(seeders)
if self.min_seeders > seeders:
continue
except:
seeders = 0
pass
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall(
'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))',
post)[0]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except:
dsize = 0
pass
info = ' | '.join(info)
sources.append({
'source': 'torrent',
'seeders': seeders,
'hash': hash,
'name': name,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize
})
except:
source_utils.scraper_error('SKYTORRENTS')
return sources
return sources
def sources(self, url, hostDict, hostprDict):
scraper = cfscrape.create_scraper()
sources = []
try:
if url is 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])
title = data['title']
aliases = data['aliases']
episode_title = data['title'] if 'tvshowtitle' in data else None
year = data['year']
query = re.sub('[^A-Za-z0-9\s\.-]+', '', title)
url = self.search_link % quote_plus(query)
url = urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
try:
r = scraper.get(url).content
if not r:
return sources
if any(value in str(r) for value in [
'No movies found', 'something went wrong',
'Connection timed out'
]):
return sources
r = json.loads(r)
id = ''
for i in r:
if i['original_title'] == title and i[
'release_date'] == year:
id = i['id']
break
if id == '':
return sources
link = '%s%s%s' % (self.base_link, '/movies/torrents?id=', id)
result = scraper.get(link).content
if 'magnet' not in result:
return sources
result = re.sub(r'\n', '', result)
links = re.findall(
r'<tr>.*?<a title="Download:\s*(.+?)"href="(magnet:.+?)">.*?title="File Size">\s*(.+?)\s*</td>.*?title="Seeds">([0-9]+|[0-9]+,[0-9]+)\s*<',
result)
for link in links:
name = link[0]
name = unquote_plus(name)
name = source_utils.clean_name(title, name)
if source_utils.remove_lang(name, episode_title):
continue
if not source_utils.check_title(title.replace('&', 'and'),
aliases, name, year, year):
continue
url = link[1]
try:
url = unquote_plus(url).decode('utf8').replace(
'&', '&').replace(' ', '.')
except:
url = unquote_plus(url).replace('&',
'&').replace(' ', '.')
url = url.split('&tr')[0]
hash = re.compile('btih:(.*?)&').findall(url)[0]
quality, info = source_utils.get_release_quality(name, url)
try:
size = link[2]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except:
dsize = 0
pass
info = ' | '.join(info)
try:
seeders = int(link[3].replace(',', ''))
if self.min_seeders > seeders:
continue
except:
seeders = 0
pass
sources.append({
'source': 'torrent',
'seeders': seeders,
'hash': hash,
'name': name,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize
})
return sources
except:
source_utils.scraper_error('MOVIEMAGNET')
return sources
except:
source_utils.scraper_error('MOVIEMAGNET')
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])
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 % quote_plus(query)
url = urljoin(self.base_link, url)
r = client.request(url)
posts = re.findall('<h2 class="title">(.+?)</h2>', r,
re.IGNORECASE)
hostDict = hostprDict + hostDict
urls = []
for item in posts:
try:
link, name = re.findall('href="(.+?)" title="(.+?)"', item,
re.IGNORECASE)[0]
if not cleantitle.get(title) in cleantitle.get(name):
continue
name = client.replaceHTMLCodes(name)
try:
_name = name.lower().replace('permalink to', '')
except:
_name = name
quality, info = source_utils.get_release_quality(
name, link)
try:
size = re.findall(
'((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|MB|MiB))',
name)[-1]
dsize, isize = source_utils._size(size)
except Exception:
dsize, isize = 0.0, ''
info.insert(0, isize)
info = ' | '.join(info)
links = self.links(link)
urls += [(i, quality, info) for i in links]
except Exception:
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')
url = ensure_text(url)
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid:
continue
host = client.replaceHTMLCodes(host)
#host = host.encode('utf-8')
host = ensure_text(host)
sources.append({
'source': host,
'quality': item[1],
'language': 'en',
'url': url,
'info': item[2],
'direct': False,
'debridonly': True,
'size': dsize,
'name': _name
})
return sources
except Exception:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
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):
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])
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(u'(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = urljoin(
self.base_link,
self.search_link.format(query[0].lower(),
cleantitle.geturl(query)))
r = client.request(url)
r = client.parseDOM(r, 'tbody')[0]
posts = client.parseDOM(r, 'tr')
posts = [i for i in posts if 'magnet:' in i]
for post in posts:
post = post.replace(' ', ' ')
name = client.parseDOM(post, 'a', ret='title')[1]
t = name.split(hdlr)[0]
if not cleantitle.get(re.sub(r'(|)', '',
t)) == cleantitle.get(title):
continue
try:
y = re.findall(
u'[\.|\(|\[|\s|\_|\-](S\d+E\d+|S\d+)[\.|\)|\]|\s|\_|\-]',
name, re.I)[-1].upper()
except BaseException:
y = re.findall(
u'[\.|\(|\[|\s\_|\-](\d{4})[\.|\)|\]|\s\_|\-]', name,
re.I)[-1].upper()
if not y == hdlr: continue
links = client.parseDOM(post, 'a', ret='href')
magnet = [
i.replace('&', '&') for i in links if 'magnet:' in i
][0]
url = magnet.split('&tr')[0]
quality, info = source_utils.get_release_quality(name, url)
try:
size = re.findall(
r'((?:\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('Magnetdl - Exception', 1)
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url is None:
return sources
if debrid.status() is False:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
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)
try:
r = client.request(url)
links = zip(client.parseDOM(r, 'a', attrs={'class': 'btn btn-default magnet-button stats-action banner-button'}, ret='href'), client.parseDOM(r, 'td', attrs={'class': 'size'}))
for link in links:
url = link[0].replace('&', '&')
url = re.sub(r'(&tr=.+)&dn=', '&dn=', url) # some links on bitlord &tr= before &dn=
url = url.split('&tr=')[0]
if 'magnet' not in url:
continue
if any(x in url.lower() for x in ['french', 'italian', 'spanish', 'truefrench', 'dublado', 'dubbed']):
continue
name = url.split('&dn=')[1]
t = name.split(hdlr)[0].replace(data['year'], '').replace('(', '').replace(')', '').replace('&', 'and')
if cleantitle.get(t) != cleantitle.get(title):
continue
if hdlr not in name:
continue
quality, info = source_utils.get_release_quality(name, url)
try:
size = int(link[1])
size = str(size) + ' GB' if len(str(size)) == 1 else str(size) + ' MB'
dsize, isize = source_utils._size(size)
except:
dsize, isize = 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})
return sources
except:
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
self._sources = []
self.items = []
if url is None:
return self._sources
if debrid.status() is False:
return self._sources
self.tvsearch = '%s/sort-category-search/%s/TV/seeders/desc/1/' % (
self.base_link, '%s')
self.moviesearch = '%s/sort-category-search/%s/Movies/size/desc/1/' % (
self.base_link, '%s')
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)
urls = []
if 'tvshowtitle' in data:
urls.append(self.tvsearch % (quote(query)))
'''
Why spam for multiple pages, since it gives plenty on each page?
urls.append(self.tvsearch.format(quote(query), '2'))
urls.append(self.tvsearch.format(quote(query), '3'))
'''
else:
urls.append(self.moviesearch % (quote(query)))
'''
Why spam for multiple pages, since it gives plenty on each page?
urls.append(self.moviesearch.format(quote(query), '2'))
urls.append(self.moviesearch.format(quote(query), '3'))
'''
threads = []
for url in urls:
threads.append(workers.Thread(self._get_items, url))
[i.start() for i in threads]
[i.join() for i in threads]
self.hostDict = hostDict + hostprDict
threads2 = []
for i in self.items:
threads2.append(workers.Thread(self._get_sources, i))
[i.start() for i in threads2]
[i.join() for i in threads2]
return self._sources
except:
log_utils.log('1337x_exc2', 1)
return self._sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None:
return sources
if debrid.status() is False:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data[
'title']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s %s' % (title, hdlr)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', '', query)
url = self.search_link % urllib.quote(query)
url = urlparse.urljoin(self.base_link, url)
# log_utils.log('url = %s' % url, log_utils.LOGDEBUG)
html = client.request(url)
html = html.replace(' ', ' ')
try:
results = client.parseDOM(html,
'table',
attrs={'id': 'searchResult'})
except:
return sources
url2 = url.replace('/1/', '/2/')
html2 = client.request(url2)
html2 = html2.replace(' ', ' ')
try:
results += client.parseDOM(html2,
'table',
attrs={'id': 'searchResult'})
except:
return sources
results = ''.join(results)
rows = re.findall('<tr(.+?)</tr>', results, re.DOTALL)
if rows is None:
return sources
for entry in rows:
try:
try:
url = 'magnet:%s' % (re.findall(
'a href="magnet:(.+?)"', entry, re.DOTALL)[0])
url = str(client.replaceHTMLCodes(url).split('&tr')[0])
except:
continue
try:
name = re.findall(
'class="detLink" title=".+?">(.+?)</a>', entry,
re.DOTALL)[0]
name = client.replaceHTMLCodes(name)
name = urllib.unquote_plus(name).replace(' ', '.')
t = name.split(hdlr)[0].replace(
data['year'],
'').replace('(', '').replace(')', '').replace(
'&', 'and').replace('.US.',
'.').replace('.us.', '.')
if cleantitle.get(t) != cleantitle.get(title):
continue
except:
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+)\s*(?:GB|GiB|MB|MiB))',
entry)[-1]
dsize, isize = utils._size(size)
except:
dsize, isize = 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
})
except:
continue
return sources
except:
return sources
