def continue_parse_video(self, fldata: FLData):
bitrates = quotes(fldata.text, "'bitrates':[{", "}]").split('},{')
for item in bitrates:
file = quotes(item, "'file':'", "'")
label = quotes(item, 'label:"', '"')
self.add_video(label, URL(file))
self.set_default_video(-1)
self.generate_video_view()
def parse_video(self, soup: BeautifulSoup, url: URL):
container = soup.find('div', {'id': 'video-content'})
if container:
script = container.find(
'script', text=lambda x: 'html5player.setVideoUrl' in str(x))
if script:
for line in script.text.split(';'):
if line.strip().startswith('html5player.setVideoUrl'):
label = quotes(line, 'setVideoUrl', '(')
video_url = URL(quotes(line, "('", "')"), base_url=url)
self.add_video(label, video_url)
self.set_default_video(-1)
def parse_video(self, soup: BeautifulSoup, url: URL):
head = soup.find('head')
if head:
script = head.find('script', text=lambda x: 'streams:' in str(x))
if script is not None:
data = str(script).replace(' ', '')
sources = quotes(data, 'streams:[{', '}]').split('},{')
for f in sources:
label = quotes(f, 'id:"', '"')
url = URL(quotes(f, 'url:"', '"'), base_url=url)
if url.contain('.mp4'):
self.add_video(label, url)
self.set_default_video(-1)
def parse_video(self, soup: BeautifulSoup, url: URL):
psp(soup)
video = soup.find('div', {'class': 'watch'})
if video:
script = video.find('script',
text=lambda x: 'redtube_flv_player' in str(x))
if script:
data = str(script.string).replace(' ', '').replace('\\', '')
psp(data)
sources = quotes(data, 'mediaDefinition:[', ']').split('},{')
for item in sources:
file = quotes(item, 'videoUrl":"', '"')
label = quotes(item, 'quality":"', '"')
if file:
self.add_video(label, URL(file, base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
content = soup.find('div', {'class': 'player'})
if content is not None:
psp(content.prettify())
script = content.find('script',
text=lambda x: 'flashvars' in str(x))
if script is not None:
data = str(script.string).replace(' ', '').replace(
'\n', '').replace('\t', '')
flashvars = quotes(data, 'flashvars={', '};').split(',')
fv = dict()
for flashvar in flashvars:
# print(flashvar)
split = flashvar.partition(':')
fv[split[0]] = split[2].strip("'\"")
files = dict()
for f in fv:
if fv[f].startswith('http://') and fv[f].endswith('.mp4/'):
file = fv[f]
label = fv.get(f + '_text', f)
files[label] = file
print("=======================didn't work?")
for key in sorted(files.keys(), reverse=True):
self.add_video(key, URL(files[key], referer=url))
def parse_thumbs(self, soup: BeautifulSoup, url: URL):
container = soup.find('div', {'class': 'mozaique'})
if container:
# psp(container.prettify())
for thumbnail in _iter(
container.find_all('div', {'class': 'thumb-block '})):
# psp(thumbnail.prettify())
xref = thumbnail.find('a')
if xref:
# psp(thumbnail.prettify())
href = URL(xref.attrs['href'], base_url=url)
script = thumbnail.find('script',
text=lambda x: 'img src' in str(x))
thumb_file = quotes(script.text, '<img src="', '"')
thumb_url = URL(thumb_file, base_url=url)
label = xref.attrs.get('title', '')
duration = thumbnail.find('span', {'class': 'duration'})
dur_time = str(
duration.string).strip('()') if duration else ''
self.add_thumb(thumb_url=thumb_url,
href=href,
popup=label,
labels=[{
'text': dur_time,
'align': 'top right'
}, {
'text': label,
'align': 'bottom center'
}])
def parse_video(self, soup: BeautifulSoup, url: URL):
player_container = soup.find('div', {'id': 'player'})
if player_container:
script = player_container.find(
'script', text=lambda text: 'jwplayer' in str(text))
if script:
text = script.string
if 'sources:[' in text:
sources = quotes(text, 'sources:[', ']')
j = json.loads('[' + sources + ']')
for j_data in j:
if j_data['file'] is not '':
self.add_video(j_data['label'],
URL(j_data['file'] + '*'))
self.set_default_video(-1)
elif 'sources:' in text:
container = soup.find('div', {'class': 'content-video'})
if container:
script = container.find(
'script', {'src': lambda x: '/player/' in str(x)})
if script:
script_url = URL(script.attrs['src'], base_url=url)
filedata = FLData(script_url, '')
self._result_type = 'video'
self.model.loader.start_load_file(
filedata, self.continue_parse_video)
def parse_video(self, soup: BeautifulSoup, url: URL):
videos_container = soup.find('div', {'id': 'videos_container'})
video_container = soup.find('div', {'itemprop': 'video'})
if videos_container:
usss=soup.find('script',text=lambda x: 'usss' in str(x))
uid=quotes(usss.string.replace(' ',''),'usss[0]="','"')
xhr_list=list()
part=1
for data_div in _iter(videos_container.find_all('div', {'class':'pl_vid_el'})):
data = {'uid': uid, 'source': data_div.attrs['data-source'], 'hash': data_div.attrs['data-hash'],
'x': data_div.attrs['data-x'],
'oid': data_div.attrs['data-oid'], 'pid': data_div.attrs['data-pid']}
xhr=URL('/php/get_vlink.php',base_url=url,method='POST',post_data=data)
xhr_list.append(YPData(xhr,' - Part {0}'.format(part)))
part += 1
loader=self.model.loader
load_process=loader.get_new_load_process(self.add_part)
self._result_type = 'video'
load_process.load_list(xhr_list)
elif video_container:
video=video_container.find('video')
if video:
self.add_video('default', URL(video.attrs['src'], base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
contents=soup.find('div',{'class':'contents'})
if contents:
script=contents.find('script',text=lambda x: 'beemPlayer' in str(x))
if script:
# psp(script.prettify())
video_url=URL(quotes(str(script.text),'file:',',').strip(' "'))
self.add_video('default',video_url)
def parse_video(self, soup: BeautifulSoup, url: URL):
content = soup.find('div', {'id': 'content'})
if content is not None:
script = content.find('script', text=lambda x: 'jwplayer(' in str(x))
if script is not None:
data = str(script.string).replace(' ', '')
file = quotes(data, '"file":"', '"')
self.add_video('DEFAULT', URL(file, base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
video = soup.find('div', {'class': 'videoDetail'})
if video is not None:
script = video.find('script', text=lambda x: 'jwplayer(' in str(x))
if script is not None:
data = str(script.string).replace(' ', '').replace(
'\t', '').replace('\n', '')
if 'sources:' in data:
sources = quotes(data, 'sources:[{', '}]').split('},{')
for item in sources:
file = quotes(item, 'file:"', '"')
label = quotes(item, 'label:"', '"')
self.add_video(label, URL(file, base_url=url))
elif "filefallback':" in data:
file = quotes(data, 'filefallback\':"', '"')
self.add_video('DEFAULT', URL(file, base_url=url))
self.set_default_video(-1)
def parse_pictures(self, soup: BeautifulSoup, url: URL):
container = soup.find('div', {'class': 'imagelinks'})
if container:
# psp(container.prettify())
base = ''
for item in _iter(container.find_all('script')):
script = str(item.string).strip()
# psp(script)
if script.startswith('var '):
base = unquote(quotes(script, "'", "'"))
# psp(base)
else:
suffix = quotes(script, "+'", "'")
image_url = URL(base + suffix)
# psp(pic_url)
# image_url=self.get_image_url(image, url)
filename = self.get_image_filename(image_url)
self.add_picture(filename, image_url)
def parse_video(self, soup: BeautifulSoup, url: URL):
content = soup.find('div', {'class': 'player'})
if content is not None:
script = content.find('script',
text=lambda x: 'flashvars =' in str(x))
if script is not None:
data = str(script.string).replace(' ', '')
file = quotes(data, "video_url:'", "'")
self.add_video('DEFAULT', URL(file, base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
video = soup.find('div', {'class': 'player'})
if video is not None:
# psp(video.prettify())
script=video.find('script', text=lambda x: 'video_url:' in str(x))
if script is not None:
data = str(script.string).replace(' ', '')#.replace('\t', '').replace('\n', '')
# psp(data)
mp4=quotes(data,"video_url:'","'")
self.add_video('DEFAULT', URL(mp4, base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
script = soup.find('script', text=lambda x: 'angular.' in str(x))
if script:
json_file_url = URL(quotes(script.string.replace(' ', ''),
"host:'", "'"),
base_url=url)
filedata = FLData(json_file_url, '')
self._result_type = 'video'
self.model.loader.start_load_file(filedata,
self.continue_parse_video)
def parse_video(self, soup: BeautifulSoup, url: URL):
scripts = soup.find_all('script', text=lambda x: 'var pageVar =' in str(x))
for script in _iter(scripts):
videovars=quotes(str(script.string).replace(' ',''),"'videoVars':{","}").split(",")
default=-1
for var in videovars:
(label,sep,href)=var.replace('"','').replace('\\','').partition(':')
if label.startswith('quality_'):
if '720' in label:
default=len(self.video_data)
self.add_video(label, URL(href))
self.set_default_video(default)
def parse_one_thumb(self, thumbnail:BeautifulSoup, url:URL):
# psp(thumbnail.prettify())
href_txt = thumbnail.attrs['href']
if 'url=' in href_txt:
href_txt = quotes(href_txt, 'url=', '&')
href = URL(href_txt.strip('/')+'/')
description = thumbnail.img.attrs.get('alt', '')
if description is '':
description = href_txt.strip('/').rpartition('/')[2].replace('-', ' ')
thumb_url = URL(thumbnail.img.attrs['src'], base_url=url)
# print(thumb_url,href,description)
self.add_thumb(thumb_url=thumb_url, href=href, popup=description,
labels=[{'text': description, 'align': 'bottom center'}])
def parse_video(self, soup: BeautifulSoup, url: URL):
video = soup.find('div', {'id': 'playerSwf'})
if video is not None:
script = video.find('script', text=lambda x: 'XPlayer' in str(x))
if script is not None:
data = str(script.string).replace(' ', '').replace('\\/', '/')
if 'sources:' in data:
sources = quotes(data, 'sources:{', '}').split('","')
for item in sources:
part = item.partition('":"')
file = part[2].strip('"')
label = part[0].strip('"')
self.add_video(label, URL(file, base_url=url))
self.set_default_video(-1)
def parse_video(self, soup: BeautifulSoup, url: URL):
content = soup.find('div', {'class': 'player-holder'})
if content is not None:
script = content.find('script',
text=lambda x: 'video_url:' in str(x))
if script is not None:
data = str(script.string).replace(' ', '')
file = quotes(data, "video_url:'", "'")
source_file = URL(file + '*', base_url=url)
filedata = FLData(source_file, '', find_redirect_location=True)
self._result_type = 'video'
self.model.loader.start_load_file(filedata,
self.continue_parse_video)
def parse_video_tags(self, soup: BeautifulSoup, url: URL):
info = soup.find('div', {'class': 'video-info'})
if info:
# psp(info.prettify())
for xref in _iter(
info.find_all('a',
href=lambda x: not 'javascript' in str(x))):
psp(xref)
href = xref.attrs['href']
if '/user/' in href:
self.add_tag(quotes(href, '/user/', '/'),
URL(href.replace('/user/', '/submitted/'),
base_url=url),
style={'color': 'blue'})
else:
self.add_tag(collect_string(xref), URL(href, base_url=url))
def parse_video(self, soup: BeautifulSoup, url: URL):
video = soup.find('div', {'class': 'video-container'})
if video is not None:
script = video.find('script', text=lambda x: 'flashvars' in str(x))
if script is not None:
data = str(script.string).replace(' ', '').replace(
'\t', '').replace('\n', '')
flashvars = quotes(data, 'flashvars={', '};').split(',')
for flashvar in flashvars:
if flashvar.startswith('"quality_'):
split = flashvar.partition('":"')
self.add_video(
split[0],
URL(split[2].rstrip('"').replace('\\/', '/'),
base_url=url))
self.set_default_video(-1)
def parse_video(self, soup: BeautifulSoup, url: URL):
container = soup.find('div', {'class': 'player-container'})
if container:
script = str(
container.find(
'script', text=lambda x: 'players.push(' in str(x)).string)
if script:
# psp(script.replace(' ',''))
sources = quotes(
script.replace(' ', '').replace('\\', ''), "sources:{",
'}').split(',')
for source in sources:
# psp(source)
split = source.partition(':')
label = split[0].strip("'\"")
file = split[2].strip("'\" ")
if file:
self.add_video(label, URL(file, base_url=url))
self.set_default_video(-1)
def parse_video(self, soup: BeautifulSoup, url: URL):
player_container = soup.find('div', {'id': 'playerContainer'})
if player_container:
script = player_container.find(
'script', text=lambda x: 'flashvars' in str(x))
flashvars = quotes(
script.string.replace('\\', '').replace(' ', ''),
'flashvars={', '};')
print(flashvars)
while '"quality_' in flashvars:
nxt = flashvars.partition('"quality_')[2]
t = nxt.partition('":"')
label = t[0]
file = t[2].partition('",')[0]
if file.startswith('http://') or file.startswith('https://'):
self.add_video(label, URL(file + '*'))
flashvars = nxt
self.set_default_video(-1)
def parse_thumbs(self, soup: BeautifulSoup, url: URL):
for thumbnail in _iter(
soup.find_all('section', {'class': 'content-video'})):
try:
# psp(thumbnail.prettify())
href = URL(thumbnail.a.attrs['href'], base_url=url)
style = thumbnail.find('div', {
'class': 'img-src',
'style': True
})
thumb_url = URL(quotes(str(style['style']), "'", "'"))
label = str(thumbnail.h3.string).strip()
duration = thumbnail.find('span', {'class': 'video-time'})
dur_time = '' if duration is None else str(duration.string)
hd_span = str(
thumbnail.find('span', {'class': 'video-resolution'}))
hd = 'HD' if 'HD.png' in hd_span else ''
self.add_thumb(thumb_url=thumb_url,
href=href,
popup=label,
labels=[{
'text': dur_time,
'align': 'top right'
}, {
'text': label,
'align': 'bottom center'
}, {
'text': hd,
'align': 'top left'
}])
except AttributeError:
pass
def parse_video(self, soup: BeautifulSoup, url: URL):
script = soup.find('script', text=lambda x: 'var urls' in str(x))
if script is not None:
self.add_video(
'DEFAULT',
URL(quotes(str(script.string), 'file:"', '"'), base_url=url))
def continue_parse_video(self, fldata: FLData):
playlist_file = URL(
quotes(fldata.text, "jwplayer().load('", "'") + '*')
filedata = FLData(playlist_file, '')
self.model.loader.start_load_file(filedata, self.continue_parse_video2)
