def get_sources(self, video):
hosters = []
sources = {}
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=.5)
match = re.search("load_player\('([^']+)", html)
if not match: return hosters
headers = {'Referer': page_url, 'Server': 'cloudflare-nginx', 'Accept': 'text/html, */*; q=0.01',
'Accept-Language': 'en-US,en;q=0.5', 'Accept-Formating': 'application/json, text/javascript', 'Accept-Encoding': 'gzip, deflate'}
headers.update(XHR)
params = {'id': match.group(1)}
player_url = scraper_utils.urljoin(self.base_url, PLAYER_URL)
html = self._http_get(player_url, params=params, headers=headers, cache_limit=1)
js_data = scraper_utils.parse_json(html, player_url)
pl_url = js_data.get('value') or js_data.get('download')
if not pl_url: return hosters
headers = {'Referer': page_url}
if pl_url.startswith('//'): pl_url = 'https:' + pl_url
html = self._http_get(pl_url, headers=headers, allow_redirect=False, cache_limit=0)
if html.startswith('http'):
streams = [(html, '')]
else:
js_data = scraper_utils.parse_json(html, pl_url)
try: streams = [(source['file'], source.get('label', '')) for source in js_data['playlist'][0]['sources']]
except: streams = []
for stream in streams:
stream_url, label = stream
if scraper_utils.get_direct_hostname(self, stream_url) == 'gvideo':
sources[stream_url] = {'quality': scraper_utils.gv_get_quality(stream_url), 'direct': True}
else:
if label:
quality = scraper_utils.height_get_quality(label)
else:
quality = QUALITIES.HIGH
sources[stream_url] = {'quality': quality, 'direct': False}
for source, value in sources.iteritems():
direct = value['direct']
quality = value['quality']
if direct:
host = scraper_utils.get_direct_hostname(self, source)
else:
host = urlparse.urlparse(source).hostname
stream_url = source + scraper_utils.append_headers({'User-Agent': scraper_utils.get_ua()})
hoster = {'multi-part': False, 'host': host, 'class': self, 'quality': quality, 'views': None, 'rating': None, 'url': stream_url, 'direct': direct}
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, require_debrid=True, cache_limit=.5)
fragment = dom_parser2.parse_dom(html, 'table',
{'class': 'links-table'})
if not fragment: return hosters
for _attrs, row in dom_parser2.parse_dom(fragment[0].content, 'tr'):
match = re.search(
"playVideo\.bind\(.*?'([^']+)(?:[^>]*>){2}(.*?)</td>", row,
re.DOTALL)
if not match: continue
stream_url, release = match.groups()
if scraper_utils.get_direct_hostname(self, stream_url) == 'gvideo':
sources = scraper_utils.parse_google(self, stream_url)
else:
sources = [stream_url]
for source in sources:
host = scraper_utils.get_direct_hostname(self, source)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(source)
direct = True
else:
host = urlparse.urlparse(source).hostname
if video.video_type == VIDEO_TYPES.MOVIE:
meta = scraper_utils.parse_movie_link(release)
else:
meta = scraper_utils.parse_episode_link(release)
base_quality = scraper_utils.height_get_quality(
meta['height'])
quality = scraper_utils.get_quality(
video, host, base_quality)
direct = False
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': source,
'direct': direct
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
headers = {
'User-Agent': scraper_utils.get_ua(),
'Referer': self.base_url + source_url
}
if video.video_type == VIDEO_TYPES.MOVIE:
meta = scraper_utils.parse_movie_link(source_url)
stream_url = source_url + scraper_utils.append_headers(headers)
quality = scraper_utils.height_get_quality(meta['height'])
hoster = {
'multi-part': False,
'host': scraper_utils.get_direct_hostname(self, stream_url),
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': True
}
if 'format' in meta: hoster['format'] = meta['format']
hosters.append(hoster)
else:
for episode in self.__match_episode(source_url, video):
meta = scraper_utils.parse_episode_link(episode['title'])
stream_url = episode['url'] + scraper_utils.append_headers(
headers)
stream_url = stream_url.replace(self.base_url, '')
quality = scraper_utils.height_get_quality(meta['height'])
hoster = {
'multi-part': False,
'host':
scraper_utils.get_direct_hostname(self, stream_url),
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': True
}
if 'format' in meta: hoster['format'] = meta['format']
if 'size' in episode:
hoster['size'] = scraper_utils.format_size(
int(episode['size']))
hosters.append(hoster)
return hosters
def get_sources(self, video):
source_url = self.get_url(video)
hosters = []
if not source_url or source_url == FORCE_NO_MATCH: return hosters
url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(url, cache_limit=.5)
sources = self.__get_posts(html)
sources.update(self.__get_ajax(html, url))
sources.update(self.__get_embedded(html, url))
for source in sources:
stream_url = source + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
host = scraper_utils.get_direct_hostname(self, source)
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': sources[source],
'views': None,
'rating': None,
'url': stream_url,
'direct': True,
'subs': 'Turkish subtitles'
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
query = scraper_utils.parse_query(source_url)
if 'id' in query:
vid_type = 'movies' if video.video_type == VIDEO_TYPES.MOVIE else 'episodes'
url = scraper_utils.urljoin(
self.base_url, '/api/v2/%s/%s' % (vid_type, query['id']))
js_data = self._http_get(url, cache_limit=.5)
if 'url' in js_data:
stream_url = js_data['url']
quality = QUALITIES.HD720
hoster = {
'multi-part': False,
'host':
scraper_utils.get_direct_hostname(self, stream_url),
'class': self,
'url': stream_url,
'quality': quality,
'views': None,
'rating': None,
'direct': True
}
hosters.append(hoster)
return hosters
def __get_links_from_json2(self, url, page_url, video_type):
sources = {}
headers = {'Referer': page_url}
headers.update(XHR)
html = self._http_get(url, headers=headers, cache_limit=0)
js_data = scraper_utils.parse_json(html, url)
try:
playlist = js_data.get('playlist', [])
for source in playlist[0].get('sources', []):
stream_url = source['file']
if scraper_utils.get_direct_hostname(self,
stream_url) == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
elif 'label' in source:
quality = scraper_utils.height_get_quality(source['label'])
else:
if video_type == VIDEO_TYPES.MOVIE:
meta = scraper_utils.parse_movie_link(stream_url)
else:
meta = scraper_utils.parse_episode_link(stream_url)
quality = scraper_utils.height_get_quality(meta['height'])
sources[stream_url] = {'quality': quality, 'direct': True}
logger.log(
'Adding stream: %s Quality: %s' % (stream_url, quality),
log_utils.LOGDEBUG)
except Exception as e:
logger.log('Exception during yesmovies extract: %s' % (e),
log_utils.LOGDEBUG)
return sources
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
for stream in self.__get_videos(source_url, video):
if video.video_type == VIDEO_TYPES.EPISODE and not scraper_utils.release_check(
video, stream['name']):
continue
host = scraper_utils.get_direct_hostname(self, stream['url'])
hoster = {
'multi-part': False,
'class': self,
'views': None,
'url': stream['url'],
'rating': None,
'host': host,
'quality': stream['quality'],
'direct': True
}
if 'size' in stream:
hoster['size'] = scraper_utils.format_size(stream['size'])
if 'name' in stream: hoster['extra'] = stream['name']
hosters.append(hoster)
return hosters
def __get_episode_sources(self, source_url, video):
hosters = []
links = self.__find_episode(source_url, video)
if not links: return hosters
hash_data = self.__get_hash_data([link[0] for link in links])
for link in links:
try:
status = hash_data['hashes'][link[0]]['status']
except KeyError:
status = ''
if status.lower() != 'finished': continue
stream_url = 'hash_id=%s' % (link[0])
host = scraper_utils.get_direct_hostname(self, stream_url)
quality = scraper_utils.blog_get_quality(video, link[1], '')
hoster = {
'multi-part': False,
'class': self,
'views': None,
'url': stream_url,
'rating': None,
'host': host,
'quality': quality,
'direct': True
}
hoster['extra'] = link[1]
hosters.append(hoster)
return hosters
def __get_links(self, html):
hosters = []
r = re.search('tlas\("([^"]+)', html)
if r:
plaintext = self.__caesar(
self.__get_f(self.__caesar(r.group(1), 13)), 13)
sources = scraper_utils.parse_sources_list(self, plaintext)
for source in sources:
stream_url = source + scraper_utils.append_headers(
{
'User-Agent': scraper_utils.get_ua(),
'Cookie': self._get_stream_cookies()
})
host = scraper_utils.get_direct_hostname(self, stream_url)
hoster = {
'multi-part': False,
'url': stream_url,
'host': host,
'class': self,
'quality': sources[source]['quality'],
'rating': None,
'views': None,
'direct': True
}
hosters.append(hoster)
return hosters
def __get_gk_links(self, html):
sources = {}
match = re.search('{link\s*:\s*"([^"]+)', html)
if match:
iframe_url = match.group(1)
data = {'link': iframe_url}
headers = {'Referer': iframe_url}
html = self._http_get(self.gk_url, data=data, headers=headers, cache_limit=.5)
js_data = scraper_utils.parse_json(html, self.gk_url)
links = js_data.get('link', [])
if isinstance(links, basestring):
links = [{'link': links}]
for link in links:
stream_url = link['link']
if scraper_utils.get_direct_hostname(self, stream_url) == 'openload.co':
quality = scraper_utils.gv_get_quality(stream_url)
direct = True
elif 'label' in link:
quality = scraper_utils.height_get_quality(link['label'])
direct = True
else:
quality = QUALITIES.HIGH
direct = False
sources[stream_url] = {'quality': quality, 'direct': direct}
return sources
def get_sources(self, video):
source_url = self.get_url(video)
hosters = []
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=.5)
fragment = dom_parser2.parse_dom(html, 'div', {'class': 'film-container'})
if fragment:
iframe_url = dom_parser2.parse_dom(fragment[0].content, 'iframe', req='src')
if iframe_url:
iframe_url = scraper_utils.urljoin(self.base_url, iframe_url[0].attrs['src'])
headers = {'Referer': page_url}
html = self._http_get(iframe_url, headers=headers, cache_limit=.5)
sources = scraper_utils.parse_sources_list(self, html)
for source in sources:
quality = sources[source]['quality']
host = scraper_utils.get_direct_hostname(self, source)
stream_url = source + scraper_utils.append_headers({'User-Agent': scraper_utils.get_ua(), 'Referer': iframe_url})
hoster = {'multi-part': False, 'host': host, 'class': self, 'quality': quality, 'views': None, 'rating': None, 'url': stream_url, 'direct': True}
match = re.search('(\d+[a-z]bps)', source)
if match:
hoster['extra'] = match.group(1)
hosters.append(hoster)
hosters.sort(key=lambda x: x.get('extra', ''), reverse=True)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=8)
for attrs, _content in dom_parser2.parse_dom(html, 'a', req='href'):
stream_url = attrs['href']
if MOVIE_URL in stream_url:
meta = scraper_utils.parse_movie_link(stream_url)
stream_url = scraper_utils.pathify_url(
stream_url) + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
quality = scraper_utils.height_get_quality(meta['height'])
hoster = {
'multi-part': False,
'host':
scraper_utils.get_direct_hostname(self, stream_url),
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': True
}
if 'format' in meta: hoster['format'] = meta['format']
hosters.append(hoster)
return hosters
def __get_cloud_links(self, html, page_url, sub):
hosters = []
html = html.replace('\\"', '"').replace('\\/', '/')
match = re.search("dizi_kapak_getir\('([^']+)", html)
if match:
ep_id = match.group(1)
for attrs, _content in dom_parser2.parse_dom(html, 'script', {'data-cfasync': 'false'}, req='src'):
script_url = attrs['src']
html = self._http_get(script_url, cache_limit=24)
match1 = re.search("var\s+kapak_url\s*=\s*'([^']+)", html)
match2 = re.search("var\s+aCtkp\s*=\s*'([^']+)", html)
if match1 and match2:
link_url = '%s?fileid=%s&access_token=%s' % (match1.group(1), ep_id, match2.group(1))
headers = {'Referer': page_url}
html = self._http_get(link_url, headers=headers, cache_limit=.5)
js_data = scraper_utils.parse_json(html, link_url)
for variant in js_data.get('variants', {}):
stream_host = random.choice(variant.get('hosts', []))
if stream_host:
stream_url = stream_host + variant['path'] + scraper_utils.append_headers({'User-Agent': scraper_utils.get_ua(), 'Referer': page_url})
if not stream_url.startswith('http'):
stream_url = 'http://' + stream_url
host = scraper_utils.get_direct_hostname(self, stream_url)
if 'width' in variant:
quality = scraper_utils.width_get_quality(variant['width'])
elif 'height' in variant:
quality = scraper_utils.height_get_quality(variant['height'])
else:
quality = QUALITIES.HIGH
hoster = {'multi-part': False, 'host': host, 'class': self, 'quality': quality, 'views': None, 'rating': None, 'url': stream_url, 'direct': True}
hoster['subs'] = sub
hosters.append(hoster)
return hosters
def __create_source(self,
stream_url,
height,
page_url,
subs=False,
direct=True):
if direct:
stream_url = stream_url.replace('\\/', '/')
if self.get_name().lower() in stream_url:
headers = {'Referer': page_url}
redir_url = self._http_get(stream_url,
headers=headers,
method='HEAD',
allow_redirect=False,
cache_limit=.25)
if redir_url.startswith('http'):
stream_url = redir_url
stream_url += scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
else:
stream_url += scraper_utils.append_headers({
'User-Agent':
scraper_utils.get_ua(),
'Referer':
page_url,
'Cookie':
self._get_stream_cookies()
})
else:
stream_url += scraper_utils.append_headers({
'User-Agent':
scraper_utils.get_ua(),
'Referer':
page_url
})
host = scraper_utils.get_direct_hostname(self, stream_url)
else:
host = urlparse.urlparse(stream_url).hostname
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
else:
quality = scraper_utils.height_get_quality(height)
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': direct
}
if subs: hoster['subs'] = 'Turkish Subtitles'
return hoster
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(url, cache_limit=.5)
views = None
fragment = dom_parser2.parse_dom(
html, 'img', {'src': re.compile('[^"]*view_icon.png')})
if fragment:
match = re.search('(\d+)', fragment[0].content)
if match:
views = match.group(1)
match = re.search('href="([^"]+-full-movie-[^"]+)', html)
if match:
url = match.group(1)
html = self._http_get(url, cache_limit=.5)
sources = self.__get_embedded(html)
for link in dom_parser2.parse_dom(html,
'span', {'class': 'btn-eps'},
req='link'):
link = link.attrs['link']
ajax_url = scraper_utils.urljoin(self.base_url, AJAX_URL)
headers = {'Referer': url}
headers.update(XHR)
html = self._http_get(ajax_url,
params={'v': link},
headers=headers,
cache_limit=.5)
sources.update(self.__get_sources(html))
for source in sources:
if sources[source]['direct']:
host = scraper_utils.get_direct_hostname(self, source)
else:
host = urlparse.urlparse(source).hostname
stream_url = source + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
direct = sources[source]['direct']
quality = sources[source]['quality']
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': quality,
'views': views,
'rating': None,
'url': stream_url,
'direct': direct
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
source_url = self.get_url(video)
hosters = []
sources = {}
headers = {'Accept-Language': 'en-US,en;q=0.5'}
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, headers=headers, cache_limit=2)
if video.video_type == VIDEO_TYPES.MOVIE:
sources.update(self.__scrape_sources(html, page_url))
pages = set([
r.attrs['href'] for r in dom_parser2.parse_dom(
html, 'a', {'class': 'btn-eps'}, req='href')
])
active = set([
r.attrs['href'] for r in dom_parser2.parse_dom(
html, 'a', {'class': 'active'}, req='href')
])
for page in list(pages - active):
page_url = scraper_utils.urljoin(self.base_url, page)
html = self._http_get(page_url, headers=headers, cache_limit=2)
sources.update(self.__scrape_sources(html, page_url))
else:
for page in self.__match_episode(video, html):
page_url = scraper_utils.urljoin(self.base_url, page)
html = self._http_get(page_url, headers=headers, cache_limit=2)
sources.update(self.__scrape_sources(html, page_url))
for source, values in sources.iteritems():
if not source.lower().startswith('http'): continue
if values['direct']:
host = scraper_utils.get_direct_hostname(self, source)
if host != 'gvideo':
stream_url = source + scraper_utils.append_headers(
{
'User-Agent': scraper_utils.get_ua(),
'Referer': page_url
})
else:
stream_url = source
else:
host = urlparse.urlparse(source).hostname
stream_url = source
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': values['quality'],
'views': None,
'rating': None,
'url': stream_url,
'direct': values['direct']
}
hosters.append(hoster)
return hosters
def __get_js_sources(self, js_data, page_url):
hosters = []
for key in js_data:
if 'videolink' in key:
stream_url = js_data[key]
if scraper_utils.get_direct_hostname(self,
stream_url) == 'gvideo':
hosters.append(
self.__create_source(stream_url, 480, page_url))
return hosters
def __get_sources(self, html, label):
sources = {}
for attrs, _label in dom_parser2.parse_dom(html, 'source', req='src'):
if scraper_utils.get_direct_hostname(self,
attrs['src']) == 'gvideo':
quality = scraper_utils.gv_get_quality(attrs['src'])
else:
quality = Q_MAP.get(label.upper(), QUALITIES.HIGH)
sources[attrs['src']] = {'direct': True, 'quality': quality}
return sources
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(url, cache_limit=.5)
views = None
fragment = dom_parser2.parse_dom(html, 'span', {'class': 'post-views'})
if fragment:
views = re.sub('[^\d]', '', fragment[0].content)
iframe_urls = []
if video.video_type == VIDEO_TYPES.MOVIE:
iframe_urls = [
r.attrs['href'] for r in dom_parser2.parse_dom(
html, 'a', {'class': ['orange', 'abutton']}, req='href')
]
else:
for label, link in self.__get_episode_links(html):
if int(label) == int(video.episode):
iframe_urls.append(link)
for iframe_url in iframe_urls:
headers = {'Referer': url}
html = self._http_get(iframe_url, headers=headers, cache_limit=.5)
match = re.search('{link\s*:\s*"([^"]+)', html)
if match:
sources = self.__get_gk_links(match.group(1), iframe_url)
else:
sources = scraper_utils.parse_sources_list(self, html)
for source in sources:
stream_url = source + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
direct = sources[source]['direct']
quality = sources[source]['quality']
if sources[source]['direct']:
host = scraper_utils.get_direct_hostname(self, source)
else:
host = urlparse.urlparse(source).hostname
hoster = {
'multi-part': False,
'url': stream_url,
'class': self,
'quality': quality,
'host': host,
'rating': None,
'views': views,
'direct': direct
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
source_url = self.get_url(video)
hosters = []
if not source_url or source_url == FORCE_NO_MATCH: return hosters
url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(url, cache_limit=8)
hosts = [
r.content for r in dom_parser2.parse_dom(
html, 'p', {'class': 'server_servername'})
]
links = [
r.content
for r in dom_parser2.parse_dom(html, 'p', {'class': 'server_play'})
]
for host, link_frag in zip(hosts, links):
stream_url = dom_parser2.parse_dom(link_frag, 'a', req='href')
if not stream_url: continue
stream_url = stream_url[0].attrs['href']
host = re.sub('^Server\s*', '', host, re.I)
host = re.sub('\s*Link\s+\d+', '', host)
if host.lower() == 'google':
sources = self.__get_gvideo_links(stream_url)
else:
sources = [{'host': host, 'link': stream_url}]
for source in sources:
host = scraper_utils.get_direct_hostname(self, stream_url)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
stream_url = source['link'] + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
direct = True
else:
stream_url = scraper_utils.pathify_url(source['link'])
host = HOST_SUB.get(source['host'].lower(), source['host'])
quality = scraper_utils.get_quality(
video, host, QUALITIES.HIGH)
direct = False
hoster = {
'multi-part': False,
'url': stream_url,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'direct': direct
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
sources = {}
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=.5)
for match in re.finditer(
'player-data="([^"]+)[^>]+episode-data="([^"]+)[^>]*>(.*?)</a>',
html, re.DOTALL):
player_url, ep_id, label = match.groups()
if video.video_type == VIDEO_TYPES.EPISODE and not self.__episode_match(
video, ep_id):
continue
label = label.strip()
headers = {'Referer': page_url}
if re.match('https?://embed', player_url):
src_html = self._http_get(player_url,
headers=headers,
cache_limit=.5)
sources.update(scraper_utils.parse_sources_list(
self, src_html))
sources.update(self.__get_sources(src_html, label))
else:
sources[player_url] = {
'direct': False,
'quality': Q_MAP.get(label.upper(), QUALITIES.HIGH)
}
for source, value in sources.iteritems():
direct = value['direct']
quality = value['quality']
if direct:
host = scraper_utils.get_direct_hostname(self, source)
stream_url = source + scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
else:
host = urlparse.urlparse(source).hostname
stream_url = source
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': direct
}
hosters.append(hoster)
return hosters
def __get_embedded_links(self, html, sub):
hosters = []
html = html.replace('\\"', '"').replace('\\/', '/')
sources = scraper_utils.parse_sources_list(self, html)
for source in sources:
host = scraper_utils.get_direct_hostname(self, source)
quality = sources[source]['quality']
direct = sources[source]['direct']
hoster = {'multi-part': False, 'host': host, 'class': self, 'quality': quality, 'views': None, 'rating': None, 'url': source, 'direct': direct}
hoster['subs'] = sub
hosters.append(hoster)
return hosters
def __get_links(self, url, video):
hosters = []
search_url, params = self.__translate_search(url)
html = self._http_get(search_url, params=params, cache_limit=.5)
js_result = scraper_utils.parse_json(html, search_url)
down_url = js_result.get('downURL')
dl_farm = js_result.get('dlFarm')
dl_port = js_result.get('dlPort')
for item in js_result.get('data', []):
post_hash, size, post_title, ext, duration = item['0'], item['4'], item['10'], item['11'], item['14']
checks = [False] * 6
if not scraper_utils.release_check(video, post_title): checks[0] = True
if 'alangs' in item and item['alangs'] and 'eng' not in item['alangs']: checks[1] = True
if re.match('^\d+s', duration) or re.match('^[0-5]m', duration): checks[2] = True
if 'passwd' in item and item['passwd']: checks[3] = True
if 'virus' in item and item['virus']: checks[4] = True
if 'type' in item and item['type'].upper() != 'VIDEO': checks[5] = True
if any(checks):
logger.log('EasyNews Post excluded: %s - |%s|' % (checks, item), log_utils.LOGDEBUG)
continue
stream_url = down_url + urllib.quote('/%s/%s/%s%s/%s%s' % (dl_farm, dl_port, post_hash, ext, post_title, ext))
stream_url = stream_url + '|Authorization=%s' % (urllib.quote(self.auth))
host = scraper_utils.get_direct_hostname(self, stream_url)
quality = None
if 'width' in item:
try: width = int(item['width'])
except: width = 0
if width:
quality = scraper_utils.width_get_quality(width)
if quality is None:
if video.video_type == VIDEO_TYPES.MOVIE:
meta = scraper_utils.parse_movie_link(post_title)
else:
meta = scraper_utils.parse_episode_link(post_title)
quality = scraper_utils.height_get_quality(meta['height'])
if self.max_bytes:
match = re.search('([\d.]+)\s+(.*)', size)
if match:
size_bytes = scraper_utils.to_bytes(*match.groups())
if size_bytes > self.max_bytes:
logger.log('Result skipped, Too big: |%s| - %s (%s) > %s (%s GB)' % (post_title, size_bytes, size, self.max_bytes, self.max_gb))
continue
hoster = {'multi-part': False, 'class': self, 'views': None, 'url': stream_url, 'rating': None, 'host': host, 'quality': quality, 'direct': True}
if any(i for i in ['X265', 'HEVC'] if i in post_title.upper()): hoster['format'] = 'x265'
if size: hoster['size'] = size
if post_title: hoster['extra'] = post_title
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=8)
fragment = dom_parser2.parse_dom(html, 'div', {'class': 'playex'})
if fragment: html = fragment[0].content
iframe_url = dom_parser2.parse_dom(html, 'iframe', req='src')
if not iframe_url: return hosters
iframe_url = iframe_url[0].attrs['src']
if iframe_url.startswith('/'):
iframe_url = scraper_utils.urljoin(self.base_url, iframe_url)
html = self._http_get(iframe_url,
headers={'Referer': page_url},
cache_limit=.5)
obj = dom_parser2.parse_dom(html, 'object', req='data')
if obj:
streams = dict((stream_url, {
'quality': scraper_utils.gv_get_quality(stream_url),
'direct': True
}) for stream_url in scraper_utils.parse_google(
self, obj[0].attrs['data']))
else:
streams = scraper_utils.parse_sources_list(self, html)
for stream_url, values in streams.iteritems():
host = scraper_utils.get_direct_hostname(self, stream_url)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
else:
quality = values['quality']
stream_url += scraper_utils.append_headers({
'User-Agent':
scraper_utils.get_ua(),
'Referer':
page_url
})
source = {
'multi-part': False,
'url': stream_url,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'direct': True
}
hosters.append(source)
return hosters
def __get_gk_links(self, link, iframe_url):
sources = {}
data = {'link': link}
headers = XHR
headers.update({'Referer': iframe_url, 'User-Agent': USER_AGENT})
html = self._http_get(GK_URL,
data=data,
headers=headers,
cache_limit=.25)
js_data = scraper_utils.parse_json(html, GK_URL)
if 'link' in js_data:
if isinstance(js_data['link'], basestring):
stream_url = js_data['link']
if scraper_utils.get_direct_hostname(self,
stream_url) == 'gvideo':
for source in scraper_utils.parse_google(self, stream_url):
sources[source] = {
'quality': scraper_utils.gv_get_quality(source),
'direct': True
}
else:
sources[stream_url] = {
'quality': QUALITIES.HIGH,
'direct': False
}
else:
for link in js_data['link']:
stream_url = link['link']
if scraper_utils.get_direct_hostname(
self, stream_url) == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
elif 'label' in link:
quality = scraper_utils.height_get_quality(
link['label'])
else:
quality = QUALITIES.HIGH
sources[stream_url] = {'quality': quality, 'direct': True}
return sources
def __get_gk_links2(self, html):
sources = {}
match = re.search('proxy\.link=([^"&]+)', html)
if match:
proxy_link = match.group(1)
proxy_link = proxy_link.split('*', 1)[-1]
if len(proxy_link) <= 224:
vid_url = scraper_utils.gk_decrypt(self.get_name(), GK_KEY1, proxy_link)
else:
vid_url = scraper_utils.gk_decrypt(self.get_name(), GK_KEY2, proxy_link)
if scraper_utils.get_direct_hostname(self, vid_url) == 'openload.co':
for source in self._parse_gdocs(vid_url):
sources[source] = {'quality': scraper_utils.gv_get_quality(source), 'direct': True}
return sources
def __get_sources(self, html):
sources = scraper_utils.parse_sources_list(self, html)
for source in dom_parser2.parse_dom(
html, 'source', {'type': 'video/mp4'},
req='src') + dom_parser2.parse_dom(html, 'iframe', req='src'):
source = source.attrs['src']
if scraper_utils.get_direct_hostname(self, source) == 'gvideo':
quality = scraper_utils.gv_get_quality(source)
direct = True
else:
quality = QUALITIES.HD720
direct = False
sources[source] = {'quality': quality, 'direct': direct}
return self.__proc_sources(sources)
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=.5)
iframe_url = dom_parser2.parse_dom(html,
'iframe', {'id': 'myiframe'},
req='src',
exclude_comments=True)
if not iframe_url: return hosters
iframe_url = iframe_url[0].attrs['src']
html = self._http_get(iframe_url,
headers={'Referer': page_url},
cache_limit=.5)
for source in dom_parser2.parse_dom(html,
'source', {'type': 'video/mp4'},
req=['src', 'data-res']):
stream_url = source.attrs['src']
host = scraper_utils.get_direct_hostname(self, stream_url)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
stream_url += scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
else:
quality = scraper_utils.height_get_quality(
source.attrs['data-res'])
stream_url += scraper_utils.append_headers({
'User-Agent':
scraper_utils.get_ua(),
'Referer':
page_url
})
source = {
'multi-part': False,
'url': stream_url,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'direct': True
}
hosters.append(source)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
page_url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(page_url, cache_limit=0)
match = re.search('var\s*video_id\s*=\s*"([^"]+)', html)
if not match: return hosters
video_id = match.group(1)
headers = {'Referer': page_url}
headers.update(XHR)
_html = self._http_get(scraper_utils.urljoin(self.base_url, 'av'),
headers=headers,
method='POST',
cache_limit=0)
vid_url = scraper_utils.urljoin(self.base_url, VIDEO_URL)
html = self._http_get(vid_url,
data={'v': video_id},
headers=headers,
cache_limit=0)
for source, value in scraper_utils.parse_json(html,
vid_url).iteritems():
match = re.search('url=(.*)', value)
if not match: continue
stream_url = urllib.unquote(match.group(1))
host = scraper_utils.get_direct_hostname(self, stream_url)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(stream_url)
else:
quality = scraper_utils.height_get_quality(source)
stream_url += scraper_utils.append_headers(
{'User-Agent': scraper_utils.get_ua()})
hoster = {
'multi-part': False,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'url': stream_url,
'direct': True
}
hosters.append(hoster)
return hosters
def get_sources(self, video):
hosters = []
source_url = self.get_url(video)
if not source_url or source_url == FORCE_NO_MATCH: return hosters
url = scraper_utils.urljoin(self.base_url, source_url)
html = self._http_get(url, cache_limit=8)
for _attrs, fragment in dom_parser2.parse_dom(html, 'div',
{'class': 'movieplay'}):
iframe_src = dom_parser2.parse_dom(fragment, 'iframe', req='src')
if iframe_src:
iframe_src = iframe_src[0].attrs['src']
if re.search('o(pen)?load', iframe_src, re.I):
meta = scraper_utils.parse_movie_link(iframe_src)
quality = scraper_utils.height_get_quality(meta['height'])
links = {iframe_src: {'quality': quality, 'direct': False}}
else:
links = self.__get_links(iframe_src, url)
for link in links:
direct = links[link]['direct']
quality = links[link]['quality']
if direct:
host = scraper_utils.get_direct_hostname(self, link)
if host == 'gvideo':
quality = scraper_utils.gv_get_quality(link)
stream_url = link + scraper_utils.append_headers(
{
'User-Agent': scraper_utils.get_ua(),
'Referer': url
})
else:
host = urlparse.urlparse(link).hostname
stream_url = link
source = {
'multi-part': False,
'url': stream_url,
'host': host,
'class': self,
'quality': quality,
'views': None,
'rating': None,
'direct': direct
}
hosters.append(source)
return hosters
