def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None: return
urldata = urlparse.parse_qs(url)
urldata = dict((i, urldata[i][0]) for i in urldata)
title = urldata['title'].replace(':', ' ').lower()
year = urldata['year']
search_id = title.lower()
start_url = urlparse.urljoin(self.base_link, self.search_link % (search_id.replace(' ','+') + '+' + year))
headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'}
html = client.request(start_url,headers=headers)
Links = re.compile('a href="(.+?)" title="(.+?)"',re.DOTALL).findall(html)
for link,name in Links:
if title.lower() in name.lower():
if year in name:
holder = client.request(link,headers=headers)
Alterjnates = re.compile('<button class="text-capitalize dropdown-item" value="(.+?)"',re.DOTALL).findall(holder)
for alt_link in Alterjnates:
alt_url = alt_link.split ("e=")[1]
valid, host = source_utils.is_host_valid(alt_url, hostDict)
sources.append({'source':host,'quality':'1080p','language': 'en','url':alt_url,'info':[],'direct':False,'debridonly':False})
return sources
except:
failure = traceback.format_exc()
log_utils.log('1080PMovies - Exception: \n' + str(failure))
return sources
def yandex(url):
try:
cookie = client.request(url, output='cookie')
r = client.request(url, cookie=cookie)
r = re.sub(r'[^\x00-\x7F]+', ' ', r)
sk = re.findall('"sk"\s*:\s*"([^"]+)', r)[0]
idstring = re.findall('"id"\s*:\s*"([^"]+)', r)[0]
idclient = binascii.b2a_hex(os.urandom(16))
post = {
'idClient': idclient,
'version': '3.9.2',
'sk': sk,
'_model.0': 'do-get-resource-url',
'id.0': idstring
}
post = urllib.urlencode(post)
r = client.request('https://yadi.sk/models/?_m=do-get-resource-url',
post=post,
cookie=cookie)
r = json.loads(r)
url = r['models'][0]['data']['file']
return url
except:
return
def resolve(self, url):
try:
urldata = urlparse.parse_qs(url)
urldata = dict((i, urldata[i][0]) for i in urldata)
post = {
'ipplugins': 1,
'ip_film': urldata['data-film'],
'ip_server': urldata['data-server'],
'ip_name': urldata['data-name'],
'fix': "0"
}
p1 = client.request(
'http://freeputlockers.org/ip.file/swf/plugins/ipplugins.php',
post=post,
referer=urldata['url'],
XHR=True)
p1 = json.loads(p1)
p2 = client.request(
'http://freeputlockers.org/ip.file/swf/ipplayer/ipplayer.php?u=%s&s=%s&n=0'
% (p1['s'], urldata['data-server']))
p2 = json.loads(p2)
p3 = client.request(
'http://freeputlockers.org/ip.file/swf/ipplayer/api.php?hash=%s'
% (p2['hash']))
p3 = json.loads(p3)
n = p3['status']
if n == False:
p2 = client.request(
'http://freeputlockers.org/ip.file/swf/ipplayer/ipplayer.php?u=%s&s=%s&n=1'
% (p1['s'], urldata['data-server']))
p2 = json.loads(p2)
url = "https:%s" % p2["data"].replace("\/", "/")
return url
except:
return
def __login(self):
try:
if (self.login == '' or self.password == ''):
return
url = urlparse.urljoin(self.base_link, '/login')
post = urllib.urlencode({
'email': self.login,
'password': self.password,
'autoLogin': '******'
})
header = {'User-Agent': self.user_agent, 'Accept': 'text/html'}
cookie = client.request(url,
headers=header,
referer=url,
post=post,
output='cookie')
data = client.request(url, cookie=cookie, output='extended')
if '/home/logout' in data[0]:
self.cookie = cookie
return
return
except:
return
def links(self, url):
urls = []
try:
if url is None: return
r = client.request(url)
r = client.parseDOM(r, 'div', attrs={'class': 'entry'})
r = client.parseDOM(r, 'a', ret='href')
r1 = [(i) for i in r if 'money' in i][0]
r = client.request(r1)
r = client.parseDOM(r, 'div', attrs={'id': 'post-\d+'})[0]
if 'enter the password' in r:
plink = client.parseDOM(r, 'form', ret='action')[0]
post = {'post_password': '******', 'Submit': 'Submit'}
send_post = client.request(plink, post=post, output='cookie')
link = client.request(r1, cookie=send_post)
else:
link = client.request(r1)
link = re.findall('<strong>Single(.+?)</tr', link, re.DOTALL)[0]
link = client.parseDOM(link, 'a', ret='href')
link = [(i.split('=')[-1]) for i in link]
for i in link:
urls.append(i)
return urls
except:
pass
def __search(self, search_link, imdb, titles):
try:
query = search_link % (urllib.quote_plus(
cleantitle.query(titles[0])))
query = urlparse.urljoin(self.base_link, query)
t = [cleantitle.get(i) for i in set(titles) if i]
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'big-list'})
r = dom_parser.parse_dom(r, 'table', attrs={'class': 'row'})
r = dom_parser.parse_dom(r, 'td', attrs={'class': 'list-name'})
r = dom_parser.parse_dom(r, 'a', req='href')
r = [
i.attrs['href'] for i in r
if i and cleantitle.get(i.content) in t
][0]
url = source_utils.strip_domain(r)
r = client.request(urlparse.urljoin(self.base_link, url))
r = dom_parser.parse_dom(r,
'a',
attrs={'href': re.compile('.*/tt\d+.*')},
req='href')
r = [re.findall('.+?(tt\d+).*?', i.attrs['href']) for i in r]
r = [i[0] for i in r if i]
return url if imdb in r else None
except:
return
def resolve(self, url):
try:
url = client.request(urlparse.urljoin(self.base_link, url),
output='geturl')
if self.base_link not in url:
return url
header = {'User-Agent': self.user_agent, 'Accept': 'text/html'}
self.__login()
cookie = self.cookie
try:
res = client.request(url,
headers=header,
cookie=cookie,
redirect=False,
output='geturl')
if self.base_link not in res:
url = res
else:
control.infoDialog(control.lang(32572).encode('utf-8'),
sound=True,
icon='WARNING')
except:
return
return url
except:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if not url:
return
query = urlparse.urljoin(self.base_link, url)
r = client.request(query)
r = dom_parser.parse_dom(r,
'td',
attrs={
'data-title-name':
re.compile('Season %02d' %
int(season))
})
r = dom_parser.parse_dom(r, 'a', req='href')[0].attrs['href']
r = client.request(urlparse.urljoin(self.base_link, r))
r = dom_parser.parse_dom(r,
'td',
attrs={
'data-title-name':
re.compile('Episode %02d' %
int(episode))
})
r = dom_parser.parse_dom(r, 'a', req='href')[0].attrs['href']
return source_utils.strip_domain(r)
except:
return
def searchMovie(self, title, year, aliases, headers):
try:
for alias in aliases:
url = '%s/full-movie/%s' % (self.base_link,
cleantitle.geturl(alias['title']))
url = client.request(url,
headers=headers,
output='geturl',
timeout='10')
if not url == None and url != self.base_link: break
if url == None:
for alias in aliases:
url = '%s/full-movie/%s-%s' % (self.base_link,
cleantitle.geturl(
alias['title']), year)
url = client.request(url,
headers=headers,
output='geturl',
timeout='10')
if not url == None and url != self.base_link: break
return url
except:
failure = traceback.format_exc()
log_utils.log('CartoonHD - Exception: \n' + str(failure))
return
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
r = client.request(urlparse.urljoin(self.base_link,
self.conf_link),
XHR=True)
r = json.loads(r).get('streamer')
r = client.request(r + '%s.mp4/master.m3u8' % url, XHR=True)
r = re.findall('RESOLUTION\s*=\s*\d+x(\d+).*?\n(http.*?)(?:\n|$)',
r, re.IGNORECASE)
r = [(source_utils.label_to_quality(i[0]), i[1]) for i in r]
for quality, link in r:
sources.append({
'source': 'CDN',
'quality': quality,
'language': 'de',
'url': link,
'direct': True,
'debridonly': False
})
return sources
except:
return sources
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if url == None: return
url = urlparse.parse_qs(url)
url = dict([(i, url[i][0]) if url[i] else (i, '') for i in url])
url['premiered'], url['season'], url[
'episode'] = premiered, season, episode
try:
clean_title = cleantitle.geturl(
url['tvshowtitle']) + '-season-%d' % int(season)
search_url = urlparse.urljoin(
self.base_link,
self.search_link % clean_title.replace('-', '+'))
r = client.request(search_url)
r = client.parseDOM(r, 'div', {'id': 'movie-featured'})
r = [(client.parseDOM(i, 'a', ret='href'),
re.findall('<b><i>(.+?)</i>', i)) for i in r]
r = [(i[0][0], i[1][0]) for i in r
if cleantitle.get(i[1][0]) == cleantitle.get(clean_title)]
url = r[0][0]
except:
pass
data = client.request(url)
data = client.parseDOM(data, 'div', attrs={'id': 'details'})
data = zip(client.parseDOM(data, 'a'),
client.parseDOM(data, 'a', ret='href'))
url = [(i[0], i[1]) for i in data if i[0] == str(int(episode))]
return url[0][1]
except:
return
def __search(self, titles, year, imdb):
try:
query = self.search_link % urllib.quote_plus(cleantitle.query(titles[0]))
query = urlparse.urljoin(self.base_link, query)
t = [cleantitle.get(i) for i in set(titles) if i]
y = ['%s' % str(year), '%s' % str(int(year) + 1), '%s' % str(int(year) - 1), '0']
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'movie_cell'})
r = [(dom_parser.parse_dom(i, 'div', attrs={'class': 'bottom'}), dom_parser.parse_dom(i, 'div', attrs={'class': 'year'})) for i in r]
r = [(dom_parser.parse_dom(i[0], 'a', req=['href', 'title']), re.findall('[(](\d{4})[)]', i[1][0].content)) for i in r if i[0] and i[1]]
r = [(i[0][0].attrs['href'], i[0][0].content, i[1][0]) for i in r if i[0] and i[1]]
r = [(i[0], i[1].lower(), i[2]) for i in r if i[2] in y]
r = sorted(r, key=lambda i: int(i[2]), reverse=True) # with year > no year
r = [i[0] for i in r if cleantitle.get(i[1]) in t]
if len(r) > 1:
for i in r:
data = client.request(urlparse.urljoin(self.base_link, i))
data = dom_parser.parse_dom(data, 'a', attrs={'name': re.compile('.*/tt\d+.*')}, req='name')
data = [re.findall('.+?(tt\d+).*?', d.attrs['name']) for d in data]
data = [d[0] for d in data if len(d) > 0 and d[0] == imdb]
if len(data) >= 1:
url = i
else:
url = r[0]
if url:
return source_utils.strip_domain(url)
except:
return
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
url = urlparse.urljoin(self.base_link, data.get('url'))
season = data.get('season')
episode = data.get('episode')
if season and episode:
r = urllib.urlencode({
'imdbid': data['imdb'],
'language': 'de',
'season': season,
'episode': episode
})
r = client.request(urlparse.urljoin(self.base_link,
self.hoster_link),
XHR=True,
post=r)
else:
r = client.request(url)
r = dom_parser.parse_dom(r, 'div', attrs={'class':
'linkbox'})[0].content
r = re.compile('(<a.+?/a>)', re.DOTALL).findall(r)
r = [(dom_parser.parse_dom(i, 'a', req='href'),
dom_parser.parse_dom(
i,
'img',
attrs={'class': re.compile('.*linkbutton')},
req='class')) for i in r]
r = [(i[0][0].attrs['href'], i[1][0].attrs['class'].lower())
for i in r if i[0] and i[1]]
r = [(i[0].strip(), 'HD' if i[1].startswith('hd') else 'SD')
for i in r]
for url, quli in r:
valid, host = source_utils.is_host_valid(url, hostDict)
if not valid: continue
sources.append({
'source': host,
'quality': quli,
'language': 'de',
'url': url,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
aliases = eval(data['aliases'])
headers = {}
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, headers=headers, timeout='10', output='geturl')
if url == None:
url = self.searchShow(data['tvshowtitle'], data['season'], aliases, headers)
else:
url = self.searchMovie(data['title'], data['year'], aliases, headers)
if url == None: raise Exception()
r = client.request(url, headers=headers, timeout='10')
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:
if '123movieshd' in link or 'seriesonline' in link:
r = client.request(link, headers=headers, timeout='10')
r = re.findall('(https:.*?redirector.*?)[\'\"]', r)
for i in r:
try: sources.append({'source': 'gvideo', 'quality': directstream.googletag(i)[0]['quality'], 'language': 'en', 'url': i, 'direct': True, 'debridonly': False})
except: pass
else:
try:
host = re.findall('([\w]+[.][\w]+)$', urlparse.urlparse(link.strip().lower()).netloc)[0]
if not host in hostDict: raise Exception()
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({'source': host, 'quality': 'SD', 'language': 'en', 'url': link, 'direct': False, 'debridonly': False})
except:
pass
return sources
except:
failure = traceback.format_exc()
log_utils.log('Series9 - Exception: \n' + str(failure))
return sources
def sources(self, url, hostDict, hostprDict):
try:
sources = []
try:
search_url = url['url']
post = url['post']
referer = urlparse.urljoin(self.film_web, post['urlstrony'])
result = client.request(search_url, post=post, referer=referer)
if not result.startswith('http'):
return sources
valid, host = source_utils.is_host_valid(result, hostDict)
q = source_utils.check_sd_url(result)
info = ''
if 'lektor' in result:
info = 'Lektor'
if 'napisy' in result:
info = 'Napisy'
first_found = {
'source': host,
'quality': '720p',
'language': 'pl',
'url': result,
'info': info,
'direct': False,
'debridonly': False
}
first_found['info'] = self.get_info_from_others(sources)
sources.append(first_found)
except:
pass
search_more_post = url['more']
#search_url = urlparse.urljoin(self.base_link, self.search_more)
result = client.request(self.base_link2, post=search_more_post)
provider = client.parseDOM(result, 'option', ret='value')
links = client.parseDOM(result, 'div', ret='data')
wersja = client.parseDOM(result, 'div', attrs={'class': 'wersja'})
#result = dom_parser.parse_dom(result, 'a')
counter = 0
for link in links:
valid, host = source_utils.is_host_valid(link, hostDict)
if not valid: continue
q = source_utils.check_sd_url(link)
sources.append({
'source': host,
'quality': q,
'language': 'pl',
'url': link,
'info': wersja[counter],
'direct': False,
'debridonly': False
})
counter += 1
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if url == None: return sources
result = client.request(url[0])
id = client.parseDOM(result, 'meta', ret='content')
for item in id:
if '?f=' in item:
index = item.find('=')
id = item[index + 1:]
break
result = client.request(self.streaminit + str(id)).replace(
'\\u0022', '\"')
quality = []
info = ''
url[1] = url[1].lower()
if '1080p' in result:
quality.append('1080p')
if '720p' in result:
quality.append('720p')
if '480p' in result:
quality.append('SD')
if '360p' in result:
quality.append('SD')
if 'lektor' in url[1]:
info = 'Lektor'
if 'pl' in url[1]:
info = 'Lektor'
if 'napisy' in url[1]:
info = 'Napisy'
if 'dub' in url[1]:
info = 'Dubbing'
if 'dubbing' in url[1]:
info = 'Dubbing'
index_stream_start = result.find('"streamUrl":"') + 13
index_stream_end = result.find('","refreshUrl')
result = result[index_stream_start:index_stream_end]
result = result.replace('\\u0026', '&').replace('\\', '').replace(
'\\', '').replace('\\', '').replace('\\', '').replace(
'\\', '').replace('\\',
'').replace('n=',
'n=' + quality[0] + '_')
url[0] = 'https://' + result
sources.append({
'source': 'Movieneo',
'quality': quality[0],
'language': 'pl',
'url': url[0],
'info': info,
'direct': True,
'debridonly': False
})
return sources
except:
return sources
def resolve(self, url):
try:
r = client.request(url, output='extended')
url_res = client.parseDOM(r[0], 'a', attrs={'class':'submit'}, ret='href')[0]
mycookie = self.crazy_cookie_hash(r[4])
r = client.request(url_res, cookie=mycookie)
return client.parseDOM(r, 'iframe', ret='src')[0]
except:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return sources
url = urlparse.urljoin(self.base_link, url)
for i in range(3):
result = client.request(url, timeout=10)
if not result == None: break
dom = dom_parser.parse_dom(result,
'div',
attrs={
'class': 'links',
'id': 'noSubs'
})
result = dom[0].content
links = re.compile(
'<tr\s*>\s*<td><i\s+class="fa fa-youtube link-logo"></i>([^<]+).*?href="([^"]+)"\s+class="watch',
re.DOTALL).findall(result)
for link in links[:5]:
try:
url2 = urlparse.urljoin(self.base_link, link[1])
for i in range(2):
result2 = client.request(url2, timeout=3)
if not result2 == None: break
r = re.compile('href="([^"]+)"\s+class="action-btn'
).findall(result2)[0]
valid, hoster = source_utils.is_host_valid(r, hostDict)
if not valid: continue
#log_utils.log('JairoxDebug1: %s - %s' % (url2,r), log_utils.LOGDEBUG)
urls, host, direct = source_utils.check_directstreams(
r, hoster)
for x in urls:
sources.append({
'source': host,
'quality': x['quality'],
'language': 'en',
'url': x['url'],
'direct': direct,
'debridonly': False
})
except:
#traceback.print_exc()
pass
#log_utils.log('JairoxDebug2: %s' % (str(sources)), log_utils.LOGDEBUG)
return sources
except:
return sources
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
url = urlparse.urljoin(self.base_link, data.get('url', ''))
imdb = data.get('imdb')
season = data.get('season')
episode = data.get('episode')
if season and episode and imdb:
r = urllib.urlencode({'val': 's%se%s' % (season, episode), 'IMDB': imdb})
r = client.request(urlparse.urljoin(self.base_link, self.episode_link), XHR=True, post=r)
else:
r = client.request(url)
l = dom_parser.parse_dom(r, 'select', attrs={'id': 'sel_sprache'})
l = dom_parser.parse_dom(l, 'option', req='id')
r = [(dom_parser.parse_dom(r, 'div', attrs={'id': i.attrs['id']})) for i in l if i.attrs['id'] == 'deutsch']
r = [(i[0], dom_parser.parse_dom(i[0], 'option', req='id')) for i in r]
r = [(id.attrs['id'], dom_parser.parse_dom(content, 'div', attrs={'id': id.attrs['id']})) for content, ids in r for id in ids]
r = [(re.findall('hd(\d{3,4})', i[0]), dom_parser.parse_dom(i[1], 'a', req='href')) for i in r if i[1]]
r = [(i[0][0] if i[0] else '0', [x.attrs['href'] for x in i[1]]) for i in r if i[1]]
r = [(source_utils.label_to_quality(i[0]), i[1]) for i in r]
for quality, urls in r:
for link in urls:
try:
data = urlparse.parse_qs(urlparse.urlparse(link).query, keep_blank_values=True)
if 'm' in data:
data = data.get('m')[0]
link = base64.b64decode(data)
link = link.strip()
valid, host = source_utils.is_host_valid(link, hostDict)
if not valid: continue
sources.append({'source': host, 'quality': quality, 'language': 'de', 'url': link, 'direct': False, 'debridonly': False, 'checkquality': True})
except:
pass
return sources
except:
return sources
def resolve(self, url):
if self.base_link in url:
try:
r = client.request(url)
v = re.findall('document.write\(Base64.decode\("(.+?)"\)',
r)[0]
b64 = base64.b64decode(v)
url = client.parseDOM(b64, 'iframe', ret='src')[0]
except:
r = client.request(url)
r = client.parseDOM(r, 'div', attrs={'class': 'player'})
url = client.parseDOM(r, 'a', ret='href')[0]
return url
def sources(self, url, hostDict, hostprDict):
sources = []
try:
if not url:
return sources
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '')
for i in data])
id = data.get('id')
season = data.get('season')
episode = data.get('episode')
if season and episode:
r = client.request(urlparse.urljoin(self.base_link,
self.get_episodes),
post={
'series_id': id,
'mlang': 'de',
'season': season,
'episode': episode
})
r = json.loads(r).get('episode_links', [])
r = [([i.get('id')], i.get('hostername')) for i in r]
else:
data.update({'lang': 'de'})
r = client.request(urlparse.urljoin(self.base_link,
self.get_links),
post=data)
r = json.loads(r).get('links', [])
r = [(i.get('ids'), i.get('hoster')) for i in r]
for link_ids, hoster in r:
valid, host = source_utils.is_host_valid(hoster, hostDict)
if not valid: continue
for link_id in link_ids:
sources.append({
'source': host,
'quality': 'SD',
'language': 'de',
'url': self.out_link % (link_id, hoster),
'direct': False,
'debridonly': False
})
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': 'player'})
r = dom_parser.parse_dom(r, 'iframe', req='src')
r = client.request(r[0][0]['src'])
r = dom_parser.parse_dom(r,
'a',
attrs={'class': 'play_container'},
req='href')
r = client.request(r[0][0]['href'])
url = self.get_link % (
re.search('(?<=var id = \")(.*?)(?=\")', r).group(),
re.search('(?<=var links = \")(.*?)(?=\")', r).group())
r = client.request(url)
r = dom_parser.parse_dom(r, 'ul', attrs={'id': 'articleList'})
r = dom_parser.parse_dom(r, 'a')
for i in r:
if 'http' in i[0]['href']:
link = i[0]['href']
elif 'http' in i[0]['onclick']:
link = re.search('http(.*?)(?=\")',
i[0]['onclick']).group()
else:
return sources
valid, hoster = source_utils.is_host_valid(link, hostDict)
if not valid: continue
sources.append({
'source': hoster,
'quality': 'SD',
'language': 'de',
'url': link,
'direct': False,
'debridonly': False
})
return sources
except:
return sources
def __search(self, titles):
try:
query = self.search_link % (urllib.quote_plus(
cleantitle.query(titles[0])))
query = urlparse.urljoin(self.base_link, query)
t = [cleantitle.get(i) for i in set(titles) if i]
r = client.request(query)
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'nag'})
r = dom_parser.parse_dom(r, 'div', attrs={'class': 'item-video'})
r = dom_parser.parse_dom(r, 'h2', attrs={'class': 'entry-title'})
r = dom_parser.parse_dom(r, 'a', req='href')
for i in r:
title = i[1]
if re.search('\*(?:.*?)\*', title) is not None:
title = re.sub('\*(?:.*?)\*', '', title)
title = cleantitle.get(title)
if title in t:
return source_utils.strip_domain(i[0]['href'])
else:
return
except:
return
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
try:
t = cleantitle.get(tvshowtitle)
q = urllib.quote_plus(cleantitle.query(tvshowtitle))
p = urllib.urlencode({'term': q})
r = client.request(self.search_link, post=p, XHR=True)
try: r = json.loads(r)
except: r = None
r = None
if r:
r = [(i['seo_url'], i['value'], i['label']) for i in r if 'value' in i and 'label' in i and 'seo_url' in i]
else:
r = proxy.request(self.search_link_2 % q, 'tv shows')
r = client.parseDOM(r, 'div', attrs = {'valign': '.+?'})
r = [(client.parseDOM(i, 'a', ret='href'), client.parseDOM(i, 'a', ret='title'), client.parseDOM(i, 'a')) for i in r]
r = [(i[0][0], i[1][0], i[2][0]) for i in r if i[0] and i[1] and i[2]]
r = [(i[0], i[1], re.findall('(\d{4})', i[2])) for i in r]
r = [(i[0], i[1], i[2][-1]) for i in r if i[2]]
r = [i for i in r if t == cleantitle.get(i[1]) and year == i[2]]
url = r[0][0]
url = proxy.parse(url)
url = url.strip('/').split('/')[-1]
url = url.encode('utf-8')
return url
except:
failure = traceback.format_exc()
log_utils.log('XWatchSeries - Exception: \n' + str(failure))
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
if url == None: return
r = client.request(url, cookie='check=2')
m = dom_parser.parse_dom(r, 'table', attrs={'class':
'show_links'})[0]
links = re.findall('k">(.*?)<.*?f="(.*?)"', m.content)
for link in links:
try:
sources.append({
'source': link[0],
'quality': 'SD',
'language': 'en',
'url': link[1],
'direct': False,
'debridonly': False
})
except:
pass
return sources
except:
return sources
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if not url:
return
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
tvshowtitle = data['tvshowtitle']
localtvshowtitle = data['localtvshowtitle']
aliases = source_utils.aliases_to_array(eval(data['aliases']))
url = self.__search([localtvshowtitle] + aliases, data['year'], season)
if not url and tvshowtitle != localtvshowtitle: url = self.__search([tvshowtitle] + aliases, data['year'], season)
if not url: return
r = client.request(urlparse.urljoin(self.base_link, url))
r = dom_parser.parse_dom(r, 'ul', attrs={'class': ['list-inline', 'list-film']})
r = dom_parser.parse_dom(r, 'li')
r = dom_parser.parse_dom(r, 'a', req='href')
r = [(i.attrs['href'], i.content) for i in r if i]
r = [(i[0], i[1] if re.compile("^(\d+)$").match(i[1]) else '0') for i in r]
r = [i[0] for i in r if int(i[1]) == int(episode)][0]
return source_utils.strip_domain(r)
except:
return
def __search(self, titles, year, season='0'):
try:
query = self.search_link % (urllib.quote_plus(cleantitle.query(titles[0])))
query = urlparse.urljoin(self.base_link, query)
t = [cleantitle.get(i) for i in set(titles) if i]
y = ['%s' % str(year), '%s' % str(int(year) + 1), '%s' % str(int(year) - 1), '0']
r = client.request(query)
r = dom_parser.parse_dom(r, 'ul', attrs={'class': ['products', 'row']})
r = dom_parser.parse_dom(r, 'div', attrs={'class': ['box-product', 'clearfix']})
if int(season) > 0:
r = [i for i in r if dom_parser.parse_dom(i, 'div', attrs={'class': 'episode'})]
else:
r = [i for i in r if not dom_parser.parse_dom(i, 'div', attrs={'class': 'episode'})]
r = dom_parser.parse_dom(r, 'h3', attrs={'class': 'title-product'})
r = dom_parser.parse_dom(r, 'a', req='href')
r = [(i.attrs['href'], i.content.lower()) for i in r if i]
r = [(i[0], i[1], re.findall('(.+?) \(*(\d{4})', i[1])) for i in r]
r = [(i[0], i[2][0][0] if len(i[2]) > 0 else i[1], i[2][0][1] if len(i[2]) > 0 else '0') for i in r]
r = [(i[0], i[1], i[2], re.findall('(.+?)\s+(?:staf+el|s)\s+(\d+)', i[1])) for i in r]
r = [(i[0], i[3][0][0] if len(i[3]) > 0 else i[1], i[2], i[3][0][1] if len(i[3]) > 0 else '0') for i in r]
r = [(i[0], i[1].replace(' hd', ''), i[2], '1' if int(season) > 0 and i[3] == '0' else i[3]) for i in r]
r = sorted(r, key=lambda i: int(i[2]), reverse=True) # with year > no year
r = [i[0]for i in r if cleantitle.get(i[1]) in t and i[2] in y and int(i[3]) == int(season)][0]
url = source_utils.strip_domain(r)
url = url.replace('-info', '-stream')
return url
except:
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
r = client.request(url)
r = dom_parser2.parse_dom(r, 'p', {'class': 'server_play'})
r = [dom_parser2.parse_dom(i, 'a', req=['href']) for i in r if i]
r = [(i[0].attrs['href'],
re.search('/(\w+).html', i[0].attrs['href'])) for i in r
if i]
r = [(i[0], i[1].groups()[0]) for i in r if i[0] and i[1]]
for i in r:
try:
host = i[1]
if str(host) in str(hostDict):
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': i[0].replace('\/', '/'),
'direct': False,
'debridonly': False
})
except:
pass
return sources
except Exception:
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
try:
if url == None: return
result = client.request(url)
# cant user dom parser here because HTML is bugged div is not closed
result = re.findall('<ul class="episodios">(.*?)</ul>', result,
re.MULTILINE | re.DOTALL)
for item in result:
season_episodes = re.findall('<li>(.*?)</li>', item,
re.MULTILINE | re.DOTALL)
for row in season_episodes:
s = client.parseDOM(row,
'div',
attrs={'class':
'numerando'})[0].split('x')
season_found = s[0].strip()
episode_found = s[1].strip()
if (season_found != season):
break
if episode_found == episode:
return client.parseDOM(row, 'a', ret='href')[0]
except:
return
def do_search(self, title, local_title, year, video_type):
try:
url = urlparse.urljoin(self.base_link, self.search_link)
url = url % urllib.quote_plus(cleantitle.query(title))
result = client.request(url)
result = client.parseDOM(result, 'div', attrs={'class': 'item'})
for row in result:
row_type = client.parseDOM(row,
'div',
attrs={'class': 'typepost'})[0]
if row_type != video_type:
continue
names = client.parseDOM(row, 'span', attrs={'class': 'tt'})[0]
names = names.split('/')
year_found = client.parseDOM(row,
'span',
attrs={'class': 'year'})
titles = [cleantitle.get(i) for i in [title, local_title]]
if self.name_matches(names, titles,
year) and (len(year_found) == 0
or year_found[0] == year):
url = client.parseDOM(row, 'a', ret='href')[0]
return urlparse.urljoin(self.base_link, url)
except:
return
