def get_sources_packs(self, link):
# log_utils.log('link = %s' % str(link), __name__, log_utils.LOGDEBUG)
try:
headers = {'User-Agent': client.agent()}
r = py_tools.ensure_str(self.scraper.get(link, headers=headers).content, errors='replace')
if not r or '<table' not in r: return
table = client.parseDOM(r, 'table', attrs={'class': 'table2'})[0]
rows = client.parseDOM(table, 'tr')
if not rows: return
except:
source_utils.scraper_error('LIMETORRENTS')
return
for row in rows:
try:
data = client.parseDOM(row, 'a', ret='href')[0]
if '/search/' in data: continue
data = re.sub(r'\s', '', data).strip()
hash = re.compile(r'/torrent/(.+?).torrent', re.I).findall(data)[0]
name = re.findall(r'title\s*=\s*(.+?)$', data, re.DOTALL | re.I)[0]
name = source_utils.clean_name(name)
url = 'magnet:?xt=urn:btih:%s&dn=%s' % (hash, name)
if not self.search_series:
if not self.bypass_filter:
if not source_utils.filter_season_pack(self.title, self.aliases, self.year, self.season_x, name):
continue
package = 'season'
elif self.search_series:
if not self.bypass_filter:
valid, last_season = source_utils.filter_show_pack(self.title, self.aliases, self.imdb, self.year, self.season_x, name, self.total_seasons)
if not valid: continue
else:
last_season = self.total_seasons
package = 'show'
name_info = source_utils.info_from_name(name, self.title, self.year, season=self.season_x, pack=package)
if source_utils.remove_lang(name_info): continue
try:
seeders = int(client.parseDOM(row, 'td', attrs={'class': 'tdseed'})[0].replace(',', ''))
if self.min_seeders > seeders: continue
except: seeders = 0
quality, info = source_utils.get_release_quality(name_info, url)
try:
size = re.findall(r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))', row)[0]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except: dsize = 0
info = ' | '.join(info)
item = {'provider': 'limetorrents', 'source': 'torrent', 'seeders': seeders, 'hash': hash, 'name': name, 'name_info': name_info, 'quality': quality,
'language': 'en', 'url': url, 'info': info, 'direct': False, 'debridonly': True, 'size': dsize, 'package': package}
if self.search_series: item.update({'last_season': last_season})
self.sources.append(item)
except:
source_utils.scraper_error('LIMETORRENTS')
def __init__(self):
self.priority = 24
self.language = ['en']
self.domains = ['rmz.cr', 'rapidmoviez.site']
self.base_link = 'http://rmz.cr/'
self.search_link = 'search/%s'
# self.base_link = 'http://rapidmoviez.cr/' # cloudflare IUAM challenge failure
self.scraper = cfscrape.create_scraper()
self.headers = {'User-Agent': client.agent()}
def get_items(self, url):
try:
headers = {'User-Agent': client.agent()}
r = client.request(url, headers=headers, timeout='10')
if not r or '<tbody' not in r: return
posts = client.parseDOM(r, 'tbody')[0]
posts = client.parseDOM(posts, 'tr')
except:
source_utils.scraper_error('1337X')
return
for post in posts:
try:
data = client.parseDOM(post, 'a', ret='href')[1]
link = urljoin(self.base_link, data)
name = client.parseDOM(post, 'a')[1]
name = source_utils.clean_name(unquote_plus(name))
if not source_utils.check_title(self.title, self.aliases, name,
self.hdlr, self.year):
continue
name_info = source_utils.info_from_name(
name, self.title, self.year, self.hdlr, self.episode_title)
if source_utils.remove_lang(name_info): continue
if not self.episode_title: #filter for eps returned in movie query (rare but movie and show exists for Run in 2020)
ep_strings = [
r'[.-]s\d{2}e\d{2}([.-]?)', r'[.-]s\d{2}([.-]?)',
r'[.-]season[.-]?\d{1,2}[.-]?'
]
if any(
re.search(item, name.lower())
for item in ep_strings):
continue
try:
seeders = int(
client.parseDOM(post,
'td',
attrs={'class': 'coll-2 seeds'
})[0].replace(',', ''))
if self.min_seeders > seeders: continue
except:
seeders = 0
try:
size = re.findall(
r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))',
post)[0]
dsize, isize = source_utils._size(size)
except:
isize = '0'
dsize = 0
self.items.append(
(name, name_info, link, isize, dsize, seeders))
except:
source_utils.scraper_error('1337X')
def get_sources(self, link):
# log_utils.log('link = %s' % link, log_utils.LOGDEBUG)
try:
headers = {'User-Agent': client.agent()}
r = py_tools.ensure_str(self.scraper.get(link, headers=headers).content, errors='replace')
if not r or '<table' not in r: return
table = client.parseDOM(r, 'table', attrs={'class': 'table2'})[0]
rows = client.parseDOM(table, 'tr')
if not rows: return
except:
source_utils.scraper_error('LIMETORRENTS')
return
for row in rows:
try:
data = client.parseDOM(row, 'a', ret='href')[0]
if '/search/' in data: continue
data = re.sub(r'\s', '', data).strip()
hash = re.compile(r'/torrent/(.+?).torrent', re.I).findall(data)[0]
name = re.findall(r'title\s*=\s*(.+?)$', data, re.DOTALL | re.I)[0]
name = source_utils.clean_name(name)
if not source_utils.check_title(self.title, self.aliases, name, self.hdlr, self.year): continue
name_info = source_utils.info_from_name(name, self.title, self.year, self.hdlr, self.episode_title)
if source_utils.remove_lang(name_info): continue
url = 'magnet:?xt=urn:btih:%s&dn=%s' % (hash, name)
if not self.episode_title: #filter for eps returned in movie query (rare but movie and show exists for Run in 2020)
ep_strings = [r'[.-]s\d{2}e\d{2}([.-]?)', r'[.-]s\d{2}([.-]?)', r'[.-]season[.-]?\d{1,2}[.-]?']
if any(re.search(item, name.lower()) for item in ep_strings): continue
try:
seeders = int(client.parseDOM(row, 'td', attrs={'class': 'tdseed'})[0].replace(',', ''))
if self.min_seeders > seeders: continue
except: seeders = 0
quality, info = source_utils.get_release_quality(name_info, url)
try:
size = re.findall(r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))', row)[0]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except: dsize = 0
info = ' | '.join(info)
self.sources.append({'provider': 'limetorrents', 'source': 'torrent', 'seeders': seeders, 'hash': hash, 'name': name, 'name_info': name_info,
'quality': quality, 'language': 'en', 'url': url, 'info': info, 'direct': False, 'debridonly': True, 'size': dsize})
except:
source_utils.scraper_error('LIMETORRENTS')
def sources(self, data, hostDict):
sources = []
if not data: return sources
try:
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.year = data['year']
self.hdlr = 'S%02dE%02d' % (
int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else self.year
query = '%s %s' % (self.title, self.hdlr)
query = re.sub(r'[^A-Za-z0-9\s\.-]+', '', query)
if 'tvshowtitle' in data:
url = self.tvsearch.format(quote_plus(query))
else:
url = self.moviesearch.format(quote_plus(query))
url = '%s%s' % (self.base_link, url)
# log_utils.log('url = %s' % url)
headers = {'User-Agent': client.agent()}
result = client.request(url, headers=headers, timeout='5')
if not result: return sources
rows = client.parseDOM(result, 'tr', attrs={'class': 't-row'})
if not rows: return sources
rows = [i for i in rows if 'racker:' not in i]
except:
source_utils.scraper_error('GLODLS')
return sources
for row in rows:
try:
ref = client.parseDOM(row, 'a', ret='href')
url = [i for i in ref if 'magnet:' in i][0]
url = unquote_plus(url).replace('&', '&').replace(
' ', '.').split('&tr')[0]
hash = re.search(r'btih:(.*?)&', url, re.I).group(1).lower()
name = unquote_plus(client.parseDOM(row, 'a', ret='title')[0])
name = source_utils.clean_name(name)
if not source_utils.check_title(self.title, self.aliases, name,
self.hdlr, self.year):
continue
name_info = source_utils.info_from_name(
name, self.title, self.year, self.hdlr, self.episode_title)
if source_utils.remove_lang(name_info): continue
if not self.episode_title: #filter for eps returned in movie query (rare but movie and show exists for Run in 2020)
ep_strings = [
r'[.-]s\d{2}e\d{2}([.-]?)', r'[.-]s\d{2}([.-]?)',
r'[.-]season[.-]?\d{1,2}[.-]?'
]
if any(
re.search(item, name.lower())
for item in ep_strings):
continue
try:
seeders = int(
re.search(
r'<td.*?<font\s*color\s*=\s*["\'].+?["\']><b>([0-9]+|[0-9]+,[0-9]+)</b>',
row).group(1).replace(',', ''))
if self.min_seeders > seeders: continue
except:
seeders = 0
quality, info = source_utils.get_release_quality(
name_info, url)
try:
size = re.search(
r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))',
row).group(0)
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except:
dsize = 0
info = ' | '.join(info)
sources.append({
'provider': 'glodls',
'source': 'torrent',
'seeders': seeders,
'hash': hash,
'name': name,
'name_info': name_info,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize
})
except:
source_utils.scraper_error('GLODLS')
return sources
def get_sources_packs(self, link):
# log_utils.log('link = %s' % link, __name__, log_utils.LOGDEBUG)
try:
headers = {'User-Agent': client.agent()}
r = client.request(link, headers=headers, timeout='5')
if not r: return
posts = client.parseDOM(r,
'tr',
attrs={'id': 'torrent_latest_torrents'})
except:
source_utils.scraper_error('KICKASS2')
return
for post in posts:
try:
ref = client.parseDOM(post,
'a',
attrs={'title': 'Torrent magnet link'},
ret='href')[0]
link = ref.split('url=')[1]
url = unquote_plus(link).replace('&', '&').replace(
' ', '.').split('&tr')[0]
hash = re.compile(r'btih:(.*?)&', re.I).findall(url)[0]
name = unquote_plus(url.split('&dn=')[1])
name = source_utils.clean_name(name)
if not self.search_series:
if not self.bypass_filter:
if not source_utils.filter_season_pack(
self.title, self.aliases, self.year,
self.season_x, name):
continue
package = 'season'
elif self.search_series:
if not self.bypass_filter:
valid, last_season = source_utils.filter_show_pack(
self.title, self.aliases, self.imdb, self.year,
self.season_x, name, self.total_seasons)
if not valid: continue
else:
last_season = self.total_seasons
package = 'show'
name_info = source_utils.info_from_name(name,
self.title,
self.year,
season=self.season_x,
pack=package)
if source_utils.remove_lang(name_info): continue
try:
seeders = int(
re.findall(
r'<td\s*class\s*=\s*["\']green\s*center["\']>([0-9]+|[0-9]+,[0-9]+)</td>',
post, re.DOTALL)[0].replace(',', ''))
if self.min_seeders > seeders: continue
except:
seeders = 0
quality, info = source_utils.get_release_quality(
name_info, url)
try:
size = re.findall(
r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))',
post)[0]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except:
dsize = 0
info = ' | '.join(info)
item = {
'provider': 'kickass2',
'source': 'torrent',
'seeders': seeders,
'hash': hash,
'name': name,
'name_info': name_info,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize,
'package': package
}
if self.search_series:
item.update({'last_season': last_season})
self.sources.append(item)
except:
source_utils.scraper_error('KICKASS2')
def get_sources(self, url):
# log_utils.log('url = %s' % url, __name__, log_utils.LOGDEBUG)
try:
headers = {'User-Agent': client.agent()}
r = client.request(url, headers=headers, timeout='5')
if not r: return
posts = client.parseDOM(r,
'tr',
attrs={'id': 'torrent_latest_torrents'})
except:
source_utils.scraper_error('KICKASS2')
return
for post in posts:
try:
ref = client.parseDOM(post,
'a',
attrs={'title': 'Torrent magnet link'},
ret='href')[0]
link = ref.split('url=')[1]
url = unquote_plus(link).replace('&', '&').replace(
' ', '.').split('&tr')[0]
if url in str(self.sources): continue
hash = re.compile(r'btih:(.*?)&', re.I).findall(url)[0]
name = unquote_plus(url.split('&dn=')[1])
name = source_utils.clean_name(name)
if not source_utils.check_title(self.title, self.aliases, name,
self.hdlr, self.year):
continue
name_info = source_utils.info_from_name(
name, self.title, self.year, self.hdlr, self.episode_title)
if source_utils.remove_lang(name_info): continue
if not self.episode_title: #filter for eps returned in movie query (rare but movie and show exists for Run in 2020)
ep_strings = [
r'[.-]s\d{2}e\d{2}([.-]?)', r'[.-]s\d{2}([.-]?)',
r'[.-]season[.-]?\d{1,2}[.-]?'
]
if any(
re.search(item, name.lower())
for item in ep_strings):
continue
try:
seeders = int(
re.findall(
r'<td\s*class\s*=\s*["\']green\s*center["\']>([0-9]+|[0-9]+,[0-9]+)</td>',
post, re.DOTALL)[0].replace(',', ''))
if self.min_seeders > seeders: continue
except:
seeders = 0
quality, info = source_utils.get_release_quality(
name_info, url)
try:
size = re.findall(
r'((?:\d+\,\d+\.\d+|\d+\.\d+|\d+\,\d+|\d+)\s*(?:GB|GiB|Gb|MB|MiB|Mb))',
post)[0]
dsize, isize = source_utils._size(size)
info.insert(0, isize)
except:
dsize = 0
info = ' | '.join(info)
self.sources.append({
'provider': 'kickass2',
'source': 'torrent',
'seeders': seeders,
'hash': hash,
'name': name,
'name_info': name_info,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True,
'size': dsize
})
except:
source_utils.scraper_error('KICKASS2')
