def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
quality = dom_parser.parse_dom(
r, 'span',
attrs={'id': 'release_text'})[0].content.split(' ')[0]
quality, info = source_utils.get_release_quality(quality)
r = dom_parser.parse_dom(r,
'ul',
attrs={'class': 'currentStreamLinks'})
r = [(dom_parser.parse_dom(i, 'p', attrs={'class': 'hostName'}),
dom_parser.parse_dom(i,
'a',
attrs={'class': 'stream-src'},
req='data-id')) for i in r]
r = [(re.sub(' hd$', '', i[0][0].content.lower()),
[x.attrs['data-id'] for x in i[1]]) for i in r
if i[0] and i[1]]
for hoster, id in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append({
'source':
hoster,
'quality':
quality,
'language':
'de',
'info':
' | '.join(info + ['' if len(id) == 1 else 'multi-part']),
'url':
id,
'direct':
False,
'debridonly':
False,
'checkquality':
True
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
r = client.request(urlparse.urljoin(self.base_link, url))
links = dom_parser.parse_dom(r, 'table')
links = [i.content for i in links if dom_parser.parse_dom(i, 'span', attrs={'class': re.compile('linkSearch(-a)?')})]
links = re.compile('(<a.+?/a>)', re.DOTALL).findall(''.join(links))
links = [dom_parser.parse_dom(i, 'a', req='href') for i in links if re.findall('(.+?)\s*\(\d+\)\s*<', i)]
links = [i[0].attrs['href'] for i in links if i]
url = re.sub('/streams-\d+', '', url)
for link in links:
if '/englisch/' in link: continue
control.sleep(3000)
if link != url: r = client.request(urlparse.urljoin(self.base_link, link))
quality = 'SD'
info = []
detail = dom_parser.parse_dom(r, 'th', attrs={'class': 'thlink'})
detail = [dom_parser.parse_dom(i, 'a', req='href') for i in detail]
detail = [(i[0].attrs['href'], i[0].content.replace('▶', '').strip()) for i in detail if i]
if detail:
quality, info = source_utils.get_release_quality(detail[0][1])
r = client.request(urlparse.urljoin(self.base_link, detail[0][0]))
r = dom_parser.parse_dom(r, 'table')
r = [dom_parser.parse_dom(i, 'a', req=['href', 'title']) for i in r if not dom_parser.parse_dom(i, 'table')]
r = [(l.attrs['href'], l.attrs['title']) for i in r for l in i if l.attrs['title']]
info = ' | '.join(info)
for stream_link, hoster in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
direct = False
if hoster.lower() == 'gvideo':
direct = True
sources.append({'source': hoster, 'quality': quality, 'language': 'de', 'url': stream_link, 'info': info, 'direct': direct, 'debridonly': False, 'checkquality': True})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
rel = dom_parser.parse_dom(r, 'div', attrs={'id': 'info'})
rel = dom_parser.parse_dom(rel,
'div',
attrs={'itemprop': 'description'})
rel = dom_parser.parse_dom(rel, 'p')
rel = [re.sub('<.+?>|</.+?>', '', i.content) for i in rel]
rel = [re.findall('release:\s*(.*)', i, re.I) for i in rel]
rel = [source_utils.get_release_quality(i[0]) for i in rel if i]
quality, info = (rel[0]) if rel else ('SD', [])
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'links'})
r = dom_parser.parse_dom(r, 'table')
r = dom_parser.parse_dom(r, 'tr', attrs={'id': re.compile('\d+')})
r = [dom_parser.parse_dom(i, 'td') for i in r]
r = [(i[0], re.sub('<.+?>|</.+?>', '', i[1].content).strip())
for i in r if len(r) >= 1]
r = [(dom_parser.parse_dom(i[0], 'a', req='href'), i[1])
for i in r]
r = [(i[0][0].attrs['href'], i[1]) for i in r if i[0]]
info = ' | '.join(info)
for link, hoster in r:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append({
'source': hoster,
'quality': quality,
'language': 'de',
'url': link,
'info': info,
'direct': False,
'debridonly': False,
'checkquality': True
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'tab-plot_german'})
r = dom_parser.parse_dom(r, 'tbody')
r = dom_parser.parse_dom(r, 'tr')
for i in r:
if re.search('(?<=">)(\n.*?)(?=<\/a>)', i[1]).group().strip():
hoster = re.search('(?<=">)(\n.*?)(?=<\/a>)',
i[1]).group().strip()
link = re.search('(?<=href=\")(.*?)(?=\")', i[1]).group()
rel = re.search(
'(?<=oddCell qualityCell">)(\n.*?)(?=<\/td>)',
i[1]).group().strip()
quality, info = source_utils.get_release_quality(rel)
if not quality:
quality = 'SD'
valid, hoster = source_utils.is_host_valid(
hoster, hostDict)
if not valid: continue
sources.append({
'source': hoster,
'quality': quality,
'language': 'de',
'url': link,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None:
raise Exception()
if not (self.api and not self.api == ''):
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']
year = int(data['year']) if 'year' in data and not data['year'] == None else None
season = int(data['season']) if 'season' in data and not data['season'] == None else None
episode = int(data['episode']) if 'episode' in data and not data['episode'] == None else None
query = '%s S%02dE%02d' % (title, season, episode) if 'tvshowtitle' in data else '%s %d' % (title, year)
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
query += ' lang:%s' % self.language[0]
query = urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, self.search_link)
hostDict = hostprDict + hostDict
iterations = self.streamLimit/self.streamIncrease
last = self.streamLimit - (iterations * self.streamIncrease)
if not last:
iterations = iterations - 1
last = self.streamIncrease
iterations = iterations + 1
seen_urls = set()
for type in self.types:
searchFrom = 0
searchCount = self.streamIncrease
for offset in range(iterations):
if iterations == offset + 1: searchCount = last
urlNew = url % (type, self.api, query, searchCount, searchFrom)
searchFrom = searchFrom + self.streamIncrease
results = client.request(urlNew)
results = json.loads(results)
apistatus = results['status']
if apistatus != 'success': break
results = results['result']
added = False
for result in results:
jsonName = result['title']
jsonSize = result['sizeinternal']
jsonExtension = result['extension']
jsonLanguage = result['lang']
jsonHoster = result['hostername'].lower()
jsonLink = result['hosterurls'][0]['url']
if jsonLink in seen_urls: continue
seen_urls.add(jsonLink)
if not jsonHoster in hostDict: continue
if not self.extensionValid(jsonExtension): continue
quality, info = source_utils.get_release_quality(jsonName)
info.append(self.formatSize(jsonSize))
info.append(jsonName)
info = '|'.join(info)
sources.append({'source' : jsonHoster, 'quality': quality, 'language' : jsonLanguage, 'url' : jsonLink, 'info': info, 'direct' : False, 'debridonly' : False})
added = True
if not added:
break
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
hostDict = hostprDict + hostDict
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data[
'title']
hdlr = '%sS%02dE%02d' % (
data['year'], int(data['season']), int(data['episode'])
) if 'tvshowtitle' in data else data['year']
query = '%s %s S%02dE%02d' % (
data['tvshowtitle'], data['year'], int(data['season']),
int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (
data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
try:
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
r = self.scraper.get(url).content
posts = client.parseDOM(r, 'div', attrs={'class': 'post'})
items = []
dupes = []
for post in posts:
try:
t = client.parseDOM(post, 'a')[0]
t = re.sub('<.+?>|</.+?>', '', t)
x = re.sub(
'(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*|3D)(\.|\)|\]|\s|)(.+|)',
'', t)
if not cleantitle.get(title) in cleantitle.get(x):
raise Exception()
y = re.findall(
'[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]',
t)[-1].upper()
if not y == hdlr: raise Exception()
fmt = re.sub(
'(.+)(\.|\(|\[|\s)(\d{4}|S\d*E\d*|S\d*)(\.|\)|\]|\s)',
'', t.upper())
fmt = re.split('\.|\(|\)|\[|\]|\s|\-', fmt)
fmt = [i.lower() for i in fmt]
#if not any(i in ['1080p', '720p'] for i in fmt): raise Exception()
if len(dupes) > 2: raise Exception()
dupes += [x]
u = client.parseDOM(post, 'a', ret='href')[0]
r = self.scraper.get(u).content
u = client.parseDOM(r, 'a', ret='href')
u = [(i.strip('/').split('/')[-1], i) 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):
raise Exception()
y = re.findall(
'[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]',
name)[-1].upper()
if not y == hdlr: raise Exception()
quality, info = source_utils.get_release_quality(
name, item[1])
url = item[1]
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
url = client.replaceHTMLCodes(url)
url = url.encode('utf-8')
host = re.findall(
'([\w]+[.][\w]+)$',
urlparse.urlparse(url.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': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
return sources
except:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
scraper = cfscrape.create_scraper()
if url == None: return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
title = data['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 = scraper.get(url).content
r = client.parseDOM(r, "div", attrs={'class': 'entry-content'})[0]
r = re.sub('shareaholic-canvas.+', '', r, flags=re.DOTALL)
a_txt = ''
a_url = ''
a_txt = client.parseDOM(r, "a", attrs={'href': '.+?'})
a_url = client.parseDOM(r, "a", ret="href")
r = re.sub('<a .+?</a>', '', r, flags=re.DOTALL)
r = re.sub('<img .+?>', '', r, flags=re.DOTALL)
size = ''
pre_txt = []
pre_url = []
pres = client.parseDOM(r, "pre", attrs={'style': '.+?'})
for pre in pres:
try:
size = re.findall('([0-9,\.]+ ?(?:GB|GiB|MB|MiB))', pre)[0]
except:
pass
url0 = re.findall('https?://[^ <"\'\s]+', pre, re.DOTALL)
txt0 = [size] * len(url0)
pre_url = pre_url + url0
pre_txt = pre_txt + txt0
r = re.sub('<pre .+?</pre>', '', r, flags=re.DOTALL)
size = ''
if not 'tvshowtitle' in data:
try:
size = " " + re.findall('([0-9,\.]+ ?(?:GB|GiB|MB|MiB))',
r)[0]
except:
pass
raw_url = re.findall('https?://[^ <"\'\s]+', r, re.DOTALL)
raw_txt = [size] * len(raw_url)
pairs = zip(a_url + pre_url + raw_url, a_txt + pre_txt + raw_txt)
for pair in pairs:
try:
url = str(pair[0])
info = re.sub('<.+?>', '', pair[1])
if any(x in url for x in ['.rar', '.zip', '.iso']):
raise Exception()
if not query.lower() in re.sub('[\\\\:;*?"<>|/ \+\'\.]+',
'-', url + info).lower():
raise Exception()
size0 = info + " " + size
try:
size0 = re.findall('([0-9,\.]+ ?(?:GB|GiB|MB|MiB))',
size0)[0]
div = 1 if size0.endswith(('GB', 'GiB')) else 1024
size0 = float(re.sub('[^0-9\.]', '', size0)) / div
size0 = '%.2f GB' % size0
except:
size0 = ''
pass
quality, info = source_utils.get_release_quality(url, info)
info.append(size0)
info = ' | '.join(info)
url = url.encode('utf-8')
hostDict = hostDict + hostprDict
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid: continue
sources.append({
'source': host,
'quality': quality,
'language': 'en',
'url': url,
'info': info,
'direct': False,
'debridonly': True
})
except:
pass
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
api_key = self.get_api()
if not api_key:
return
sources = []
try:
content_type = 'episode' if 'tvshowtitle' in url else 'movie'
match = 'extended'
moderated = 'no' if content_type == 'episode' else 'yes'
search_in = ''
if content_type == 'movie':
title = url['title'].replace(':', ' ').replace(' ',
'+').replace(
'&', 'and')
title = title.replace("'", "")
year = url['year']
link = '@name+%s+%s+@files+%s+%s' \
% (title, year, title, year)
elif content_type == 'episode':
title = url['tvshowtitle'].replace(':', ' ').replace(
' ', '+').replace('&', 'and')
season = int(url['season'])
episode = int(url['episode'])
season00_ep00_SE = 's%02de%02d' % (season, episode)
season0_ep0_SE = 's%de%d' % (season, episode)
season00_ep00_X = '%02dx%02d' % (season, episode)
season0_ep0_X = '%dx%d' % (season, episode)
season0_ep00_X = '%dx%02d' % (season, episode)
link = '@name+%s+@files+%s+|+%s+|+%s+|+%s+|+%s' \
% (title, season00_ep00_SE, season0_ep0_SE, season00_ep00_X, season0_ep0_X, season0_ep00_X)
s = requests.Session()
link = (
self.base_link + self.meta_search_link %
(api_key, link, match, moderated, search_in, self.search_limit)
)
p = s.get(link)
p = json.loads(p.text)
if p['status'] != 'ok':
return
files = p['files']
for i in files:
if i['is_ready'] == '1' and i['type'] == 'video':
try:
source = 'SINGLE'
if int(i['files_num_video']) > 3:
source = 'PACK [B](x%02d)[/B]' % int(
i['files_num_video'])
file_name = i['name']
file_id = i['id']
file_dl = i['url_dl']
if content_type == 'episode':
url = '%s<>%s<>%s<>%s<>%s<>%s' % (
file_id, season00_ep00_SE, season0_ep0_SE,
season00_ep00_X, season0_ep0_X, season0_ep00_X)
details = self.details(file_name, i['size'],
i['video_info'])
else:
url = '%s<>%s<>%s+%s' % (file_id, 'movie', title,
year)
details = self.details(file_name, i['size'],
i['video_info']).split('|')
details = details[0] + ' | ' + file_name.replace(
'.', ' ')
quality = source_utils.get_release_quality(
file_name, file_dl)
sources.append({
'source': source,
'quality': quality[0],
'language': "en",
'url': url,
'info': details,
'direct': True,
'debridonly': False
})
except:
pass
else:
continue
return sources
except:
print("Unexpected error in Furk Script: source", sys.exc_info()[0])
exc_type, exc_obj, exc_tb = sys.exc_info()
print(exc_type, exc_tb.tb_lineno)
pass
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url is None: return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else data['year']
query = '%s S%02dE%02d' % (data['tvshowtitle'], int(data['season']), int(data['episode'])) if 'tvshowtitle' in data else '%s %s' % (data['title'], data['year'])
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.search_link % urllib.quote_plus(query)
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
posts = client.parseDOM(r, 'item')
hostDict = hostprDict + hostDict
items = []
for post in posts:
try:
t = client.parseDOM(post, 'title')[0]
u = client.parseDOM(post, 'link')[0]
s = re.findall('((?:\d+\.\d+|\d+\,\d+|\d+)\s*(?:GiB|MiB|GB|MB))', t)
s = s[0] if s else '0'
items += [(t, u, s) ]
except:
pass
urls = []
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): raise Exception()
y = re.findall('[\.|\(|\[|\s](\d{4}|S\d*E\d*|S\d*)[\.|\)|\]|\s]', name)[-1].upper()
if not y == hdlr: raise Exception()
quality, info = source_utils.get_release_quality(name, item[1])
if any(x in quality for x in ['CAM', 'SD']): continue
try:
size = re.sub('i', '', item[2])
div = 1 if size.endswith('GB') else 1024
size = float(re.sub('[^0-9|/.|/,]', '', size))/div
size = '%.2f GB' % size
info.append(size)
except:
pass
info = ' | '.join(info)
url = item[1]
links = self.links(url)
urls += [(i, quality, info) for i in links]
except:
pass
for item in urls:
if 'earn-money' in item[0]: continue
if any(x in item[0] for x in ['.rar', '.zip', '.iso']): continue
url = client.replaceHTMLCodes(item[0])
url = url.encode('utf-8')
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid: continue
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({'source': host, 'quality': item[1], 'language': 'en', 'url': url, 'info': item[2], 'direct': False, 'debridonly': True})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'id': 'Module'})
r = [(r, dom_parser.parse_dom(r, 'a', attrs={'href': re.compile('[^\'"]*xrel_search_query[^\'"]*')}, req='href'))]
r = [(i[0], i[1][0].attrs['href'] if i[1] else '') for i in r]
rels = dom_parser.parse_dom(r[0][0], 'a', attrs={'href': re.compile('[^\'"]*ReleaseList[^\'"]*')}, req='href')
if rels and len(rels) > 1:
r = []
for rel in rels:
relData = client.request(urlparse.urljoin(self.base_link, rel.attrs['href']))
relData = dom_parser.parse_dom(relData, 'table', attrs={'class': 'release-list'})
relData = dom_parser.parse_dom(relData, 'tr', attrs={'class': 'row'})
relData = [(dom_parser.parse_dom(i, 'td', attrs={'class': re.compile('[^\'"]*list-name[^\'"]*')}),
dom_parser.parse_dom(i, 'img', attrs={'class': 'countryflag'}, req='alt'),
dom_parser.parse_dom(i, 'td', attrs={'class': 'release-types'})) for i in relData]
relData = [(i[0][0].content, i[1][0].attrs['alt'].lower(), i[2][0].content) for i in relData if i[0] and i[1] and i[2]]
relData = [(i[0], i[2]) for i in relData if i[1] == 'deutsch']
relData = [(i[0], dom_parser.parse_dom(i[1], 'img', attrs={'class': 'release-type-stream'})) for i in relData]
relData = [i[0] for i in relData if i[1]]
#relData = dom_parser.parse_dom(relData, 'a', req='href')[:3]
relData = dom_parser.parse_dom(relData, 'a', req='href')
for i in relData:
i = client.request(urlparse.urljoin(self.base_link, i.attrs['href']))
i = dom_parser.parse_dom(i, 'div', attrs={'id': 'Module'})
i = [(i, dom_parser.parse_dom(i, 'a', attrs={'href': re.compile('[^\'"]*xrel_search_query[^\'"]*')}, req='href'))]
r += [(x[0], x[1][0].attrs['href'] if x[1] else '') for x in i]
r = [(dom_parser.parse_dom(i[0], 'div', attrs={'id': 'ModuleReleaseDownloads'}), i[1]) for i in r]
r = [(dom_parser.parse_dom(i[0][0], 'a', attrs={'class': re.compile('.*-stream.*')}, req='href'), i[1]) for i in r if len(i[0]) > 0]
for items, rel in r:
rel = urlparse.urlparse(rel).query
rel = urlparse.parse_qs(rel)['xrel_search_query'][0]
quality, info = source_utils.get_release_quality(rel)
items = [(i.attrs['href'], i.content) for i in items]
items = [(i[0], dom_parser.parse_dom(i[1], 'img', req='src')) for i in items]
items = [(i[0], i[1][0].attrs['src']) for i in items if i[1]]
items = [(i[0], re.findall('.+/(.+\.\w+)\.\w+', i[1])) for i in items]
items = [(i[0], i[1][0]) for i in items if i[1]]
info = ' | '.join(info)
for link, hoster in items:
valid, hoster = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
sources.append({'source': hoster, 'quality': quality, 'language': 'de', 'url': link, 'info': info, 'direct': False, 'debridonly': False, 'checkquality': True})
return sources
except:
return sources
