def scrape_movie(self, title, year, imdb, debrid = False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/search?query=%s' % (self.base_link, urllib.quote_plus(search_id))
#print 'scraperchk - scrape_movie - start_url: ' + start_url
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
#print html
match = re.compile('class="movie-item view-tenth".+?href="(.+?)">.+?alt="(.+?)" />.+?data-title="Quality">(.+?)<',re.DOTALL).findall(html)
for link, name, qual in match:
#print item_url1
item_url = urlparse.urljoin(self.base_link, link)
qual = qual.replace(' ','')
#print 'scraperchk - scrape_movie - name: '+name
#print 'scraperchk - scrape_movie - item_url: '+item_url
if clean_title(search_id) == clean_title(name):
#print 'scraperchk - scrape_movie - Send this URL: ' + item_url
self.get_source(item_url, title, year, start_time, qual)
print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def get_source(self, item_url, title, year, start_time, qual):
try:
#print 'PASSEDURL >>>>>>'+item_url
count = 0
headers = {'User-Agent': client.agent()}
OPEN = client.request(item_url, headers=headers)
Endlinks = re.compile('<iframe src="(.+?)"',
re.DOTALL).findall(OPEN)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for link in Endlinks:
#print 'scraperchk - scrape_movie - link: '+str(link)
count += 1
host = link.split('//')[1].replace('www.', '')
host = host.split('/')[0].split('.')[0].title()
self.sources.append({
'source': host,
'quality': qual,
'scraper': self.name,
'url': link,
'direct': False
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
#movienolimit().scrape_movie('Upgrade', '2018', '')
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
start_url = self.base_link + self.search_link + title.replace(
' ', '%20')
scraper = cfscrape.create_scraper()
html = scraper.get(start_url, timeout=10).content
match = re.compile(
'<div class="video-thumbimg">.+?href="(.+?)".+?title="(.+?)"',
re.DOTALL).findall(html)
for url, name in match:
season_name_check = title.lower().replace(' ', '')
name_check = name.replace('-', '').replace(' ', '').lower()
check = difflib.SequenceMatcher(a=season_name_check,
b=name_check)
d = check.ratio() * 100
if int(d) > 80:
#print name
html2 = scraper.get(self.base_link + url,
timeout=10).content
final_page_match = re.compile(
'<div class="vc_col-sm-8 wpb_column column_container">.+?Released:(.+?)<.+?/series/(.+?)"',
re.DOTALL).findall(html2)
for release_year, fin_url in final_page_match:
release_year = release_year.replace(' ', '')
fin_url = self.base_link + '/series/' + fin_url
if release_year == year:
self.get_sources(fin_url, title, year, '', '',
start_time)
return self.sources
except Exception as argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid=False):
try:
start_time = time.time()
season_chk = '-season-%s' %(season)
#print season_chk
search_id = clean_search(title.lower())
start_url = '%s/%s/%s' % (self.base_link, self.search_link, search_id.replace(' ', '-'))
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers, redirect=True)
match = re.compile('class="ml-item".+?href="(.+?)".+?title="(.+?)"',re.DOTALL).findall(html)
for season_url, title in match:
#print season_url
if not season_chk in season_url:
continue
#print 'PASSED season URL### ' +season_url
episode_grab = 'Season %s Episode %s ' % (season, episode)
item_url = 'https://www2.series9.io'+season_url+'/watching.html'
self.get_source(item_url, title, episode_grab, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/search?query=%s' % (self.base_link,
urllib.quote_plus(search_id))
#print 'scraperchk - scrape_movie - start_url: ' + start_url
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
#print html
match = re.compile(
'class="movie-item view-tenth".+?href="(.+?)">.+?alt="(.+?)" />.+?data-title="Quality">(.+?)<',
re.DOTALL).findall(html)
for link, name, qual in match:
#print item_url1
item_url = urlparse.urljoin(self.base_link, link)
qual = qual.replace(' ', '')
#print 'scraperchk - scrape_movie - name: '+name
#print 'scraperchk - scrape_movie - item_url: '+item_url
if clean_title(search_id) == clean_title(name):
#print 'scraperchk - scrape_movie - Send this URL: ' + item_url
self.get_source(item_url, title, year, start_time, qual)
print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
if not debrid:
return self.sources
url = {
'imdb': imdb,
'tvdb': tvdb,
'tvshowtitle': title,
'year': show_year,
'season': season,
'episode': episode
}
url = urllib.urlencode(url)
self.get_source(url, title, show_year, season, episode,
str(start_time))
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
if int(year) > 1980: return self.sources
try:
start_time = time.time()
query = urllib.quote_plus(clean_search(title.lower()))
start_url = urlparse.urljoin(self.base_link, self.search_link % query)
headers = {'User-Agent': client.agent(), 'Referer': self.base_link}
count = 0
html = client.request(start_url, headers=headers)
posts = client.parseDOM(html, 'div', attrs={'class': 'post'})
posts = [(dom_parser.parse_dom(i, 'a', req='href')[0]) for i in posts if i]
posts = [(i.attrs['href'], i.content) for i in posts if i]
post = [(i[0]) for i in posts if clean_title(i[1]) == clean_title(title)][0]
r = client.request(post, headers=headers)
y = client.parseDOM(r, 'h1')[0]
if not year in y: return self.sources
links = client.parseDOM(r, 'source', ret='src')
link = [i for i in links if i.endswith('mp4')][0]
link += '|User-Agent=%s&Referer=%s' % (client.agent(), post)
link = urllib.quote(link, ':/-_|&+=')
count += 1
self.sources.append({'source': 'bnw', 'quality': 'SD', 'scraper': self.name, 'url': link, 'direct': True})
if dev_log=='true':
end_time = time.time() - start_time
send_log(self.name,end_time,count,title,year)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
hdlr = 'S%02dE%02d' % (int(season), int(episode))
search_id = '%s %s' % (title, hdlr)
start_url = self.base_link + self.search_link % urllib.quote_plus(
search_id)
html = client.request(start_url)
items = client.parseDOM(html, 'item')
for item in items:
name = client.parseDOM(item, 'title')[0]
name = client.replaceHTMLCodes(name)
t = name.split(hdlr)[0]
if not clean_title(title) == clean_title(t):
continue
if not hdlr in name:
continue
self.get_source(item, title, year, season, episode, debrid,
start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s' % (self.base_link,
search_id.replace(' ', '+'))
#print 'scraperchk - scrape_movie - start_url: ' + start_url
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
match = re.compile('class="thumb".+?title="(.+?)".+?href="(.+?)">',
re.DOTALL).findall(html)
for name, item_url in match:
print 'scraperchk - scrape_movie - name: ' + name
#print 'scraperchk - scrape_movie - item_url: '+item_url
if year in name:
if clean_title(search_id).lower() == clean_title(
name).lower():
#print 'scraperchk - scrape_movie - Send this URL: ' + item_url
self.get_source(item_url, title, year, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid = False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s+season+%s' % (self.base_link, urllib.quote_plus(search_id), season)
headers = {'User_Agent': client.agent()}
html = client.request(start_url, headers=headers)
#print 'PAGE>>>>>>>>>>>>>>>>>'+html
posts = client.parseDOM(html, 'div', attrs={'class': 'result-item'})
posts = [(client.parseDOM(i, 'div', attrs={'class': 'details'})[0]) for i in posts if i]
posts = [i for i in posts if not 'SEO Checker' in i]
for post in posts:
try:
name = client.parseDOM(post, 'a')[0]
name = re.sub('<.+?>', '', name)
url = client.parseDOM(post, 'a', ret='href')[0]
except:
raise Exception()
tit = re.sub('(\.|\(|\[|\s)(Season)(\.|\)|\]|\s|)(.+|)', '', name, flags=re.I)
if not clean_title(title).lower() == clean_title(tit).lower():
continue
epi_id = '%sx%s/' % (season, episode)
ep_link = url.replace('/seasons/', '/episodes/')
ep_link = ep_link.split('-season')[0] + '-%s' % epi_id
self.get_source(ep_link, title, year, season, episode, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def get_source(self, start_url, title, year, season, episode, start_time):
try:
#print 'URL PASSED OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'+start_url
count = 0
headers = {'User-Agent': client.agent()}
#scraper= cfscrape.create_scraper()
#r=scraper.get(start_url, headers=headers)
r = client.request(start_url, headers=headers)
#print r
Endlinks = re.compile(
'class="imagnet icon16" href="(.+?)">.+?<font color=#004E98>(.+?)</font>.+?><b>(.+?)</b></a',
re.DOTALL).findall(r)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for Magnet, size, quality in Endlinks:
#Magnet=Magnet.replace('https://mylink.me.uk/?url=', '')
qual = quality_tags.get_release_quality(quality, None)[0]
#print Magnet + '<><><><><>'
count += 1
self.sources.append({
'source': 'Torrent',
'quality': qual + ' ' + size,
'scraper': self.name,
'url': Magnet,
'direct': False,
'debridonly': True
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = '%s %s' % (clean_search(title.lower()), year)
start_url = urlparse.urljoin(self.base_link, self.search_link % urllib.quote_plus(search_id))
headers={'User-Agent': client.agent()}
scraper = cfscrape.create_scraper()
html = scraper.get(start_url, headers=headers).content
#xbmc.log('@#@DATA:%s' % html, xbmc.LOGNOTICE)
data = client.parseDOM(html, 'div', attrs={'id': 'content_box'})[0]
data = client.parseDOM(data, 'h2') #returns a list with all search results
data = [dom_parser.parse_dom(i, 'a', req=['href', 'title'])[0] for i in data if i] #scraping url-title
links = [(i.attrs['href'], i.attrs['title']) for i in data if i] #list with link-title for each result
#links = re.compile('<header>.+?href="(.+?)" title="(.+?)"',re.DOTALL).findall(html)
#xbmc.log('@#@LINKS:%s' % links, xbmc.LOGNOTICE)
for m_url, m_title in links:
movie_year = re.findall("(\d{4})", re.sub('\d{3,4}p', '', m_title))[-1]
movie_name = m_title.split(movie_year)[0]
if not clean_title(title) == clean_title(movie_name):
continue
if not year in movie_year:
continue
url = m_url
#error_log(self.name + ' Pass',url)
self.get_source(url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid = False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s' % (self.base_link, urllib.quote_plus(search_id))
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
posts = client.parseDOM(html, 'div', attrs={'class': 'result-item'})
posts = [(client.parseDOM(i, 'div', attrs={'class': 'details'})[0]) for i in posts if i]
posts = [i for i in posts if not 'SEO Checker' in i]
for post in posts:
try:
name = client.parseDOM(post, 'a')[0]
url = client.parseDOM(post, 'a', ret='href')[0]
date = client.parseDOM(post, 'span', attrs={'class': 'year'})[0]
except:
raise Exception()
name = re.sub('<.+?>', '', name)
tit = re.sub('(\.|\(|\[|\s)(\d{4}|S\d+E\d+|S\d+)(\.|\)|\]|\s|)(.+|)', '', name, flags=re.I)
if not clean_title(title) == clean_title(tit):
continue
if not year == date:
continue
self.get_source(url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
if int(year) > 1980:
return self.sources
try:
start_time = time.time()
query = urllib.quote_plus(clean_search(title.lower()))
start_url = urlparse.urljoin(self.base_link, self.search_link % query)
headers = {'User-Agent': client.agent(), 'Referer': self.base_link}
count = 0
html = client.request(start_url, headers=headers)
posts = client.parseDOM(html, 'div', attrs={'class': 'post'})
posts = [(dom_parser.parse_dom(i, 'a', req='href')[0]) for i in posts if i]
posts = [(i.attrs['href'], i.content) for i in posts if i]
post = [(i[0]) for i in posts if clean_title(i[1]) == clean_title(title)][0]
r = client.request(post, headers=headers)
y = client.parseDOM(r, 'h1')[0]
if not year in y:
return self.sources
links = client.parseDOM(r, 'source', ret='src')
link = [i for i in links if i.endswith('mp4')][0]
link += '|User-Agent=%s&Referer=%s' % (client.agent(), post)
link = urllib.quote(link, ':/-_|&+=')
count += 1
self.sources.append({'source': 'bnw', 'quality': 'SD', 'scraper': self.name, 'url': link, 'direct': True})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name,end_time,count,title,year)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
# start_url = '%s/?s=%s' %(self.base_link,search_id.replace(' ','+'))
# headers = {'User_Agent':User_Agent}
# html = scraper.get(start_url,headers=headers,timeout=5).content
# #xbmc.log('************ Passed'+repr(html),xbmc.LOGNOTICE)
# Regex = re.compile('class="result-item".+?href="(.+?)".+?alt="(.+?)"',re.DOTALL).findall(html)
# for item_url,name in Regex: # removed date as date isnt seperate
# if not clean_title(title).lower() == clean_title(name).lower():
# continue
# if not year in name:
# continue
# movie_link = item_url
# #print 'Grabbed movie url to pass > ' + movie_link
movie_link = '%s/movies/%s-%s/' % (
self.base_link, search_id.replace(' ', '-'), year)
#print 'Grabbed movie url to pass > ' + movie_link
self.get_source(movie_link, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, 'Check Search')
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
start_url = urlparse.urljoin(
self.base_link,
self.moviesearch_link % urllib.quote_plus(clean_search(title)))
html = client.request(start_url)
posts = client.parseDOM(html,
'div',
attrs={'class': 'index_item.+?'})
posts = [(dom.parse_dom(i, 'a', req='href')[0]) for i in posts
if i]
post = [(i.attrs['href']) for i in posts
if clean_title(title) == clean_title(
re.sub('(\.|\(|\[|\s)(\d{4})(\.|\)|\]|\s|)(.+|)', '',
i.attrs['title'], re.I))][0]
#xbmc.log('@#@POST: %s' % post, xbmc.LOGNOTICE)
self.get_sources(post, title, year, '', '', start_time)
return self.sources
except Exception as argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def get_source(self, item_url, title, year, start_time, qual):
try:
#print 'PASSEDURL >>>>>>'+item_url
count = 0
OPEN = client.request(item_url)
frame = client.parseDOM(OPEN, 'iframe', ret='src')[0]
if 'openload' in frame:
count += 1
self.sources.append(
{'source': 'openload', 'quality': qual, 'scraper': self.name, 'url': frame, 'direct': False})
extra_links = re.findall('''window.open\(['"]([^'"]+)['"]\).+?server:([^<]+)''', OPEN, re.DOTALL)
for link, host in extra_links:
if not filter_host(host.replace(' ', '')): continue
link = client.replaceHTMLCodes(link).encode('utf-8')
link = urlparse.urljoin(self.base_link, link)
count += 1
self.sources.append({'source': host, 'quality': qual, 'scraper': self.name, 'url': link, 'direct': False})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
start_url = self.search + title.replace(' ', '+')
#print start_url
html = requests.get(start_url, timeout=5).content
#print html
match = re.compile(
'a class="ml-mask jt".+?".+?title="(.+?)".+?href="(.+?)"'
).findall(html)
for name, url in match:
print name
if clean_search(title).replace(
' ', '') == clean_search(name).replace(' ', ''):
get_fin_url = requests.get(url).content
get_fin_regex = re.findall(
'class="loader_ds">.+?<a href="(.+?)"', get_fin_url)[0]
fin_url = url + get_fin_regex
self.get_source(fin_url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
print argument
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
start_url = self.search + title.replace(' ', '+')
print start_url
html = requests.get(start_url, timeout=5).content
match = re.compile(
'a class="ml-mask jt".+?".+?title="(.+?)".+?href="(.+?)"'
).findall(html)
for name, url in match:
if clean_search(title).replace(
' ', '') == clean_search(name).replace(' ', ''):
epi_url = url[:-1].replace(
'/series/', '/episode/') + '-%sx%s' % (season, episode)
get_fin_url = requests.get(epi_url).content
get_fin_regex = re.findall(
'class="loader_ds">.+?<a href="(.+?)"', get_fin_url)[0]
fin_url = epi_url + get_fin_regex
self.get_source(fin_url, title, year, season, episode,
start_time)
return self.sources
except Exception, argument:
print argument
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def get_source(self, start_url, title, year, season, episode, start_time):
try:
#print 'URL PASSED OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'+start_url
count = 0
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
#print r
Endlinks = re.compile(
'class="nobr center">(.+?)</span></td>.+?title="Torrent magnet link" href="(.+?)".+?class="cellMainLink">(.+?)</a>',
re.DOTALL).findall(r)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for size, Magnet, qual in Endlinks:
Magnet = Magnet.replace('https://mylink.cx/?url=', '')
Magnet = Magnet.replace('%3A',
':').replace('%3F', '?').replace(
'%3D', '=').split('%26dn')[0]
print Magnet + '<><><><><>'
qual = quality_tags.get_release_quality(qual, None)[0]
count += 1
self.sources.append({
'source': 'Torrent',
'quality': qual + ' ' + size,
'scraper': self.name,
'url': Magnet,
'direct': False,
'debridonly': True
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/search?query=%s' % (self.base_link,
urllib.quote_plus(search_id))
#print 'scraperchk - scrape_movie - start_url: ' + start_url
html = client.request(start_url)
posts = client.parseDOM(html,
'div',
attrs={'class': 'one_movie-item'})
for post in posts:
data = dom.parse_dom(post,
'a',
req='href',
attrs={'class': 'movie-title'})[0]
if not clean_title(title) == clean_title(data.content):
continue
qual = client.parseDOM(post,
'span',
attrs={'data-title': 'Quality'})[0]
qual = client.replaceHTMLCodes(qual)
item_url = urlparse.urljoin(self.base_link, data.attrs['href'])
self.get_source(item_url, title, year, start_time, qual)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def get_source(self,item_url,title,year,start_time):
try:
#print 'PASSEDURL >>>>>>'+item_url
count = 0
headers = {'User-Agent': client.agent()}
OPEN = client.request(item_url, headers=headers)
frame = client.parseDOM(OPEN, 'iframe', ret='src')[0]
data = client.request(frame, headers=headers)
data = client.parseDOM(data, 'ul', attrs={'class': 'menuPlayer'})[0]
links = client.parseDOM(data, 'a', ret='href')
for link in links:
#print link+'<<<<<<<<<<<<<<<<<<<<<<<<<<'
qual = quality_tags.check_sd_url(link)
if qual == 'SD' and 'openload' in link:
data = client.request(link, headers=headers)
data = client.parseDOM(data, 'meta', ret='content')[0]
qual2, info = quality_tags.get_release_quality(data, None)
else:
qual2 = qual
count += 1
host = link.split('//')[1].replace('www.','')
host = host.split('/')[0].split('.')[0].title()
self.sources.append({'source':host, 'quality':qual2, 'scraper': self.name, 'url':link, 'direct':False})
if dev_log=='true':
end_time = time.time() - start_time
send_log(self.name,end_time,count,title,year)
except Exception, argument:
if dev_log=='true':
error_log(self.name, argument)
#hdvix().scrape_movie('Black Panther', '2018', 'tt1825683', False)
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
if not debrid:
return self.sources
hdlr = 'S%02dE%02d' % (int(season), int(episode))
query = '%s+S%02dE%02d' % (urllib.quote_plus(title), int(season),
int(episode))
query = query.replace(' ', '%20')
start_url = '%s/?query=%s&category=show' % (self.base_link, query)
#print start_url
self.get_source(start_url, title, show_year, season, episode,
str(start_time))
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def get_source(self, start_url, title, year, season, episode, start_time):
try:
#print 'URL PASSED OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'+start_url
count = 0
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
#print r
Endlinks = re.compile(
'class="text-muted3 smaller pad-l2".+?style="color:green"></i>(.+?)</span>.+?rel="nofollow" href="(.+?)".+?class="progress-bar prog-blue prog-l".+?>(.+?)</div></div>',
re.DOTALL).findall(r)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for qual, Magnet, size in Endlinks:
#print Magnet + '<><><><><>'+size
count += 1
self.sources.append({
'source': 'Torrent',
'quality': size + qual,
'scraper': self.name,
'url': Magnet,
'direct': False,
'debridonly': True
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid=False):
try:
start_time = time.time()
season_chk = '-season-%s' %(season)
#print season_chk
search_id = clean_search(title.lower())
start_url = '%s/%s/%s' % (self.base_link, self.search_link, search_id.replace(' ', '-'))
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers, redirect=True)
match = re.compile('class="ml-item".+?href="(.+?)".+?title="(.+?)"',re.DOTALL).findall(html)
for season_url, title in match:
#print season_url
if not season_chk in season_url:
continue
#print 'PASSED season URL### ' +season_url
episode_grab = 'Season %s Episode %s ' % (season, episode)
item_url = 'https://www2.series9.io'+season_url+'/watching.html'
self.get_source(item_url, title, episode_grab, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
search = clean_search(title)
start_url = '%s/search.php?search=%s' % (self.base_link,
urllib.quote_plus(search))
headers = {'User-Agent': client.agent()}
link = client.request(start_url, headers=headers, timeout=5)
links = link.split('class="box"')
for p in links:
media_url = re.compile('href="([^"]+)"').findall(p)[0]
media_title = re.compile('title="([^"]+)"').findall(p)[0]
if search in clean_search(media_title.lower()):
if 'season %s' % season in media_title.lower():
self.get_source(media_url, title, year, season,
episode, start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
scrape = urllib.quote_plus(clean_search(title))
start_url = '%s/search.html?keyword=%s' % (self.base_link, scrape)
html = client.request(start_url)
thumbs = re.compile('<ul class="listing items">(.+?)</ul> ',
re.DOTALL).findall(html)
thumb = re.compile('href="(.+?)".+?alt="(.+?)"',
re.DOTALL).findall(str(thumbs))
for link, link_title in thumb:
if clean_title(title).lower() == clean_title(
link_title).lower():
page_link = urlparse.urljoin(self.base_link, link)
holdpage = client.request(page_link)
datecheck = re.compile('<span>Release: </span>(.+?)</li>',
re.DOTALL).findall(holdpage)[0]
if year in datecheck:
movie_link = re.compile(
'<li class="child_episode".+?href="(.+?)"',
re.DOTALL).findall(holdpage)[0]
movie_link = urlparse.urljoin(self.base_link,
movie_link)
self.get_source(movie_link, title, year, '', '',
start_time)
else:
pass
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_episode(self,
title,
show_year,
year,
season,
episode,
imdb,
tvdb,
debrid=False):
try:
start_time = time.time()
if not debrid:
return []
season_url = "0%s" % season if len(season) < 2 else season
episode_url = "0%s" % episode if len(episode) < 2 else episode
sea_epi = 's%se%s' % (season_url, episode_url)
start_url = "%s/?s=%s+%s" % (self.base_link, title.replace(
' ', '+').lower(), sea_epi)
OPEN = client.request(start_url)
content = re.compile('<h2><a href="([^"]+)"',
re.DOTALL).findall(OPEN)
for url in content:
if not clean_title(title).lower() in clean_title(url).lower():
continue
self.get_source(url, title, year, season, episode, start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = urllib.quote_plus('%s %s' % (title, year))
# search_id.replace(' ','+') = urllib.quote_plus(search_id)
start_url = '%s/index.php?s=%s' % (self.base_link, search_id)
#print 'CoolMovieZone - scrape_movie - start_url: ' + start_url
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
match = client.parseDOM(html, 'h1')
match = [
dom_parser.parse_dom(i, 'a', req='href') for i in match if i
]
match = [(i[0].attrs['href'], i[0].content) for i in match if i]
for item_url, name in match:
if year not in name: continue
if not clean_title(title) == clean_title(name):
continue #.lower() added on clean_title function
self.get_source(item_url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid=False):
try:
start_time = time.time()
hdlr = 'S%02dE%02d' % (int(season), int(episode))
query = clean_search(title)
query = urllib.quote_plus(query + ' ' + hdlr)
urls = []
for link in self.search_links:
try:
url = urlparse.urljoin(self.base_link, link % query)
url = urlparse.urljoin(self.base_link, url)
r = client.request(url)
posts = client.parseDOM(r, 'tbody')
posts = client.parseDOM(posts, 'tr')
urls += [(client.parseDOM(i, 'button', ret='data-clipboard-text')[0]) for i in posts if i]
except:
pass
count = 0
for url in urls:
name = url.split('/')[-1].lower()
name = client.replaceHTMLCodes(name).replace('%20', '')
if 'movies' in url:
continue
if any(x in url for x in ['italian', 'dubbed', 'teaser', 'subs', 'sub', 'dub',
'samples', 'extras', 'french', 'trailer', 'trailers', 'sample']):
continue
t = re.sub('(\.|\(|\[|\s)(S\d+E\d+|S\d+)(\.|\)|\]|\s)(.+|)', '', name, flags=re.I)
if clean_title(t) not in clean_title(title): continue
y = re.findall('[\.|\(|\[|\s](S\d+E\d+|S\d+)[\.|\)|\]|\s]', name, re.I)[-1].upper()
if not y == hdlr: continue
res, info = quality_tags.get_release_quality(name, url)
if any(x in url for x in ['hastidl', '1tehmovies', '62.210.103.107', '79.127', '213.32.113.82',
'dl5.downloadha', '89.163.255.42', '185.56.20.142', 's1.0music',
'dl3.yoozdl', 'dl4.lavinmovie.net', 'dl6.lavinmovie.net',
'dl3.upload08.com', 'dl8.uploadt.com', '163.172.6.218',
'samba.allunix.ru', 'server417']):
count += 1
url += '|User-Agent=%s&Referer=%s' % (client.agent(), self.base_link)
url = urllib.quote(url, '|:?/&+=_-')
self.sources.append(
{'source': 'DirectLink', 'quality': res, 'scraper': self.name, 'url': url, 'direct': True})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
#filepursuit().scrape_movie('Black Panther', '2018', '')
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid = False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s+season+%s' % (self.base_link, urllib.quote_plus(search_id), season)
headers = {'User_Agent': client.agent()}
html = client.request(start_url, headers=headers)
#print 'PAGE>>>>>>>>>>>>>>>>>'+html
posts = client.parseDOM(html, 'div', attrs={'class': 'result-item'})
posts = [(client.parseDOM(i, 'div', attrs={'class': 'details'})[0]) for i in posts if i]
posts = [i for i in posts if not 'SEO Checker' in i]
for post in posts:
try:
name = client.parseDOM(post, 'a')[0]
name = re.sub('<.+?>', '', name)
url = client.parseDOM(post, 'a', ret='href')[0]
except:
raise Exception()
tit = re.sub('(\.|\(|\[|\s)(Season)(\.|\)|\]|\s|)(.+|)', '', name, flags=re.I)
if not clean_title(title).lower() == clean_title(tit).lower():
continue
epi_id = '%sx%s/' % (season, episode)
ep_link = url.replace('/seasons/', '/episodes/')
ep_link = ep_link.split('-season')[0] + '-%s' % epi_id
self.get_source(ep_link, title, year, season, episode, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s' % (self.base_link,
urllib.quote_plus(search_id))
#print start_url
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
grab = re.compile(
'class="TPost C".+?<a href="(.+?)">.+?class="Title">(.+?)</div> <span class="Year">(.+?)</span>',
re.DOTALL).findall(r)
for url, name, date in grab:
#print url+'>>>>>>'
name = name.lower()
#print name+'<<<<<<<<<<'
if clean_title(title) == clean_title(name):
if date == year:
self.get_source(url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def scrape_movie(self, title, year, imdb, debrid = False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s' % (self.base_link, urllib.quote_plus(search_id))
headers = {'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
posts = client.parseDOM(html, 'div', attrs={'class': 'result-item'})
posts = [(client.parseDOM(i, 'div', attrs={'class': 'details'})[0]) for i in posts if i]
posts = [i for i in posts if not 'SEO Checker' in i]
for post in posts:
try:
name = client.parseDOM(post, 'a')[0]
url = client.parseDOM(post, 'a', ret='href')[0]
date = client.parseDOM(post, 'span', attrs={'class': 'year'})[0]
except:
raise Exception()
name = re.sub('<.+?>', '', name)
tit = re.sub('(\.|\(|\[|\s)(\d{4}|S\d+E\d+|S\d+)(\.|\)|\]|\s|)(.+|)', '', name, flags=re.I)
if not clean_title(title) == clean_title(tit):
continue
if not year == date:
continue
self.get_source(url, title, year, '', '', start_time)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def get_source(self, url, title, year, season, episode, start_time):
sources = []
try:
count = 0
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])
self.title = data['tvshowtitle']
self.hdlr = 'S%02dE%02d' % (int(data['season']), int(data['episode']))
query = '%s S%02dE%02d' % (data['tvshowtitle'], int(data['season']), int(data['episode']))
query = re.sub('(\\\|/| -|:|;|\*|\?|"|\'|<|>|\|)', ' ', query)
url = self.tvsearch.format(urllib.quote_plus(query).replace('+', '-'))
items = self._get_items(url)
for item in items:
try:
name = item[0]
quality, info = quality_tags.get_release_quality(name, name)
info.append(item[2])
info = ' | '.join(info)
url = item[1]
url = url.split('&tr')[0]
count += 1
qual = '{0} | {1}'.format(quality, info)
self.sources.append({'source': 'MAGNET', 'quality': qual, 'scraper': self.name, 'url': url, 'direct': False, 'debridonly': True})
except BaseException:
pass
if dev_log == 'true':
end_time = time.time() - float(start_time)
send_log(self.name, end_time, count, title, year, season=season, episode=episode)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def get_source(self, item_url, title, year, start_time):
try:
count = 0
data = requests.get(item_url).json()
for item in data:
title = item["title"]["rendered"]
content = item["content"]["rendered"]
year2 = item["date"][:4]
if int(year) != int(year2):
continue
#Links = re.findall(r"(http.*streamango.com\/embed\/\w{1,}|https:\/\/openload\.co\/embed\/\w{1,}\/)",content)
Links = client.parseDOM(content, 'iframe', ret='src')
for link in Links:
count += 1
host = link.split('//')[1].replace('www.', '')
host = host.split('/')[0].split('.')[0].title()
label = "DVD"
self.sources.append({
'source': host,
'quality': label,
'scraper': self.name,
'url': link,
'direct': False
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
def get_source(self, start_url, title, year, season, episode, start_time):
try:
#print 'URL PASSED OKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'+start_url
count = 0
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
#print r
Endlinks = re.compile(
'torrent" rel="nofollow".+?img alt="(.+?)".+?href="(.+?)".+?class="is-hidden-touch">(.+?)</td>',
re.DOTALL).findall(r)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for qual, Magnet, size in Endlinks:
Magnet = Magnet.replace('%3A',
':').replace('%3F', '?').replace(
'%3D', '=').split('&dn=')[0]
print Magnet + '<><><><><>'
qual = quality_tags.get_release_quality(qual, None)[0]
count += 1
self.sources.append({
'source': 'Torrent',
'quality': qual + ' ' + size,
'scraper': self.name,
'url': Magnet,
'direct': False,
'debridonly': True
})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
#print search_id
#xbmc.log('@#@TITLE: %s' % search_id, xbmc.LOGNOTICE)
start_url = urlparse.urljoin(self.base_link, self.search_link % urllib.quote_plus(search_id))
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
posts = client.parseDOM(r, 'div', attrs={'id': 'movie-\d+'})
posts = [(client.parseDOM(i, 'h4')[0]) for i in posts if i]
#print posts
posts = [(client.parseDOM(i, 'a', ret='href')[0],
client.parseDOM(i, 'a')[0]) for i in posts if i]
#posts = [(i[0]) for i in posts if clean_title(search_id) == clean_title(i[1])]
count = 0
for link, found_title in posts:
link = urlparse.urljoin(self.base_link, link) if link.startswith('/') else link
if not clean_title(title) == clean_title(found_title): continue
result = client.request(link, headers=headers)
y = client.parseDOM(result, 'div', attrs={'class': 'showValue showValueRelease'})[0]
if not year == y: continue
streams = client.parseDOM(result, 'div', attrs={'class': 'linkTr'})
for stream in streams:
quality = client.parseDOM(stream, 'div', attrs={'class': 'linkQualityText'})[0]
link = client.parseDOM(stream, 'div', attrs={'class':'linkHidden linkHiddenUrl'})[0]
#print link
if 'vidnode' in link:
continue
if 'HD' in quality:
quality = 'HD'
else:
quality = 'SD'
host = quality_tags._give_host(link)
#print host
count += 1
self.sources.append(
{'source': host, 'quality': quality, 'scraper': self.name, 'url': link, 'direct': False})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
def get_source(self, item_url, title, year, start_time):
try:
print 'PASSEDURL >>>>>>'+item_url
count = 0
headers = {'User-Agent': client.agent()}
OPEN = client.request(item_url, headers=headers)
#print OPEN
Endlinks = dom_parser.parse_dom(OPEN, 'a', req='player-data')
Endlinks = [(i.attrs['player-data'], i.content) for i in Endlinks if i]
if 'Season' in year:
Endlinks = [(i[0], 'SD') for i in Endlinks if i[1] in year]
else:
Endlinks = [(i[0], i[1]) for i in Endlinks if i]
#print 'series8 - scrape_movie - EndLinks: '+str(Endlinks)
for link, quality in Endlinks:
qual = quality_tags.check_sd_url(quality)
if 'vidcloud' in link:
link = 'https:' + link if link.startswith('//') else link
data = client.request(link, headers=headers)
link = re.findall('''file\s*:\s*['"](.+?)['"].+?type['"]\s*:\s*['"](.+?)['"]''', data, re.DOTALL)[0]
host = link[1]
link = link[0] + '|User-Agent=%s&Referer=https://vidcloud.icu/' % client.agent()
direct = True
else:
host = link.split('//')[1].replace('www.', '')
host = host.split('/')[0].split('.')[0].title()
direct = False
count += 1
self.sources.append({'source': host, 'quality': qual, 'scraper': self.name, 'url': link, 'direct': direct})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log=='true':
error_log(self.name, argument)
return[]
#seriesonline8().scrape_movie('Black Panther', '2018', 'tt1825683', False)
#seriesonline8().scrape_episode('Suits','2011','','8','5','','')
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search = clean_search(title)
start_url = '%s/%s/%s' % (self.base_link, self.search_link, search.replace(' ', '-'))
#print 'series - scrape_movie - start_url: ' + start_url
headers={'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
match = re.compile('class="ml-item".+?href="(.+?)".+?alt="(.+?)"',re.DOTALL).findall(html)
for item_url1, name in match:
item_url = 'https://www2.series9.io'+item_url1+'/watching.html'
print 'series8 - scrape_movie - item_url: '+item_url
if clean_title(search) == clean_title(name):
#print 'series8 - scrape_movie - Send this URL: ' + item_url
self.get_source(item_url, title, year, start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log=='true':
error_log(self.name,argument)
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = '%s/?s=%s' %(self.base_link,search_id.replace(' ','+'))
#print 'scraperchk - scrape_movie - start_url: ' + start_url
headers={'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
match = re.compile('class="thumb".+?title="(.+?)".+?href="(.+?)">',re.DOTALL).findall(html)
for name, item_url in match:
print 'scraperchk - scrape_movie - name: '+name
#print 'scraperchk - scrape_movie - item_url: '+item_url
if year in name:
if clean_title(search_id).lower() == clean_title(name).lower():
#print 'scraperchk - scrape_movie - Send this URL: ' + item_url
self.get_source(item_url,title,year,start_time)
#print self.sources
return self.sources
except Exception, argument:
if dev_log=='true':
error_log(self.name,argument)
def get_source(self,item_url,title,year,start_time,qual):
try:
#print 'PASSEDURL >>>>>>'+item_url
count = 0
headers={'User-Agent': client.agent()}
OPEN = client.request(item_url, headers=headers)
Endlinks = re.compile('<iframe src="(.+?)"',re.DOTALL).findall(OPEN)
#print 'scraperchk - scrape_movie - EndLinks: '+str(Endlinks)
for link in Endlinks:
#print 'scraperchk - scrape_movie - link: '+str(link)
count += 1
host = link.split('//')[1].replace('www.','')
host = host.split('/')[0].split('.')[0].title()
self.sources.append({'source': host, 'quality': qual, 'scraper': self.name, 'url': link, 'direct': False})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year)
except Exception, argument:
if dev_log == 'true':
error_log(self.name, argument)
return self.sources
#movienolimit().scrape_movie('Upgrade', '2018', '')
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid=False):
try:
start_time = time.time()
search = clean_search(title)
start_url = '%s/search.php?search=%s' % (self.base_link, urllib.quote_plus(search))
print 'SEARCH > '+start_url
headers = {'User-Agent': client.agent()}
link = client.request(start_url, headers=headers, timeout=5)
links = link.split('class="box"')
for p in links:
media_url = re.compile('href="([^"]+)"').findall(p)[0]
media_title = re.compile('title="([^"]+)"').findall(p)[0]
if search in clean_search(media_title.lower()):
if 'season %s' % season in media_title.lower():
self.get_source(media_url, title, year, season, episode, start_time)
print self.sources
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
def scrape_episode(self, title, show_year, year, season, episode, imdb, tvdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = urlparse.urljoin(self.base_link, self.search_link % urllib.quote_plus(search_id))
#print start_url
headers = {'User-Agent': client.agent()}
r = client.request(start_url, headers=headers)
posts = client.parseDOM(r, 'div', attrs={'id': 'movie-\d+'})
posts = [(client.parseDOM(i, 'h4')[0]) for i in posts if i]
for item in posts:
name = client.parseDOM(item, 'a')[0]
link = client.parseDOM(item, 'a', ret='href')[0]
if not clean_title(title) == clean_title(name): continue
link = urlparse.urljoin(self.base_link, link)
html = client.request(link)
#<div class="season" id="season8">
sep_id = 'Season %s Serie %s' % (int(season), int(episode))
#print sep_id
seasons = client.parseDOM(html, 'div', attrs={'class': 'season'})
seasons = [i for i in seasons if 'season %s' % int(season) in i.lower()][0]
epis = re.findall('<h3>(.+?)</div>\s+</div>\s+</div>\s+</div>', seasons, re.DOTALL | re.MULTILINE)
epis = [i for i in epis if sep_id in i][0]
count = 0
streams = client.parseDOM(epis, 'div', attrs={'class': 'linkTr'})
for stream in streams:
quality = client.parseDOM(stream, 'div', attrs={'class': 'linkQualityText'})[0]
link = client.parseDOM(stream, 'div', attrs={'class': 'linkHidden linkHiddenUrl'})[0]
#print link
if 'vidnode' in link:
continue
if 'HD' in quality:
quality = 'HD'
else:
quality = 'SD'
host = quality_tags._give_host(link)
# print host
count += 1
self.sources.append(
{'source': host, 'quality': quality, 'scraper': self.name, 'url': link, 'direct': False})
if dev_log == 'true':
end_time = time.time() - start_time
send_log(self.name, end_time, count, title, year, season=season, episode=episode)
return self.sources
except Exception as argument:
if dev_log == 'true':
error_log(self.name, argument)
return []
#vkflix().scrape_movie('Black Panther', '2018', '', False)
#vkflix().scrape_episode('Suits', '2011','','8','5','','')
def scrape_movie(self, title, year, imdb, debrid=False):
try:
start_time = time.time()
search_id = clean_search(title.lower())
start_url = urlparse.urljoin(self.base_link, self.search_link % urllib.quote_plus(search_id))
headers={'User-Agent': client.agent()}
html = client.request(start_url, headers=headers)
results = client.parseDOM(html, 'div', attrs={'class': 'video_title'})
items = []
for item in results:
try:
data = dom_parser.parse_dom(item, 'a', req=['href', 'title'])[0]
t = data.content
y = re.findall('\((\d{4})\)', data.attrs['title'])[0]
qual = data.attrs['title'].split('-')[1]
link = data.attrs['href']
if not clean_title(t) == clean_title(title): continue
if not y == year: continue
items += [(link, qual)]
except:
pass
for item in items:
count = 0
try:
url = item[0] if item[0].startswith('http') else urlparse.urljoin(self.base_link, item[0])
r = client.request(url)
qual = client.parseDOM(r, 'h1')[0]
res = quality_tags.get_release_quality(item[1], qual)[0]
url = re.findall('''frame_url\s*=\s*["']([^']+)['"]\;''', r, re.DOTALL)[0]
url = url if url.startswith('http') else urlparse.urljoin('https://', url)
if 'vidlink' in url:
html = client.request(url, headers=headers)
action = re.findall("action'\s*:\s*'([^']+)", html)[0]
postID = re.findall("postID\s*=\s*'([^']+)", html)[0]
url = 'https://vidlink.org' + re.findall("var\s*url\s*=\s*'([^']+)", html)[0]
data = {'browserName': 'Firefox',
'platform': 'Win32',
'postID': postID,
'action': action}
headers['X-Requested-With'] = 'XMLHttpRequest'
headers['Referer'] = url
html = client.request(url, post=data, headers=headers)
html = jsunpack.unpack(html).replace('\\', '')
sources = json.loads(re.findall('window\.srcs\s*=\s*([^;]+)', html, re.DOTALL)[0])
for src in sources:
r = requests.head(src['url'], headers={'User-Agent': client.agent()})
if r.status_code < 400:
movie_link = src['url']
count += 1
self.sources.append({'source': 'Googlelink', 'quality': res,
'scraper': self.name, 'url': movie_link, 'direct': True})
else:
continue
except:
pass
if dev_log=='true':
end_time = time.time() - start_time
send_log(self.name,end_time, count, title,year)
#print self.sources
return self.sources
except Exception, argument:
print argument
if dev_log == 'true':
error_log(self.name,argument)
return self.sources
#watch32().scrape_movie('Black Panther', '2018', 'tt1825683', False)
