def _get_streams(self):
# Retrieve URL page and search for new type of video ID
res = http.get(self.url)
match = _id_re.search(res.text)
# Use API if match, otherwise resort to old method
if match:
vid = match.group("id")
res = http.get(API_URL.format(vid))
videos = http.json(res, schema=_video_schema)
mapper = StreamMapper(
cmp=lambda format, video: video["format"] == format)
mapper.map("hls", self._create_streams, "HLS",
HLSStream.parse_variant_playlist)
mapper.map("hds", self._create_streams, "HDS",
HDSStream.parse_manifest)
else:
res = http.get(self.url, params=dict(output="json"))
videos = http.json(res, schema=_old_video_schema)
mapper = StreamMapper(
cmp=lambda type, video: video["playerType"] == type)
mapper.map("ios", self._create_streams, "HLS",
HLSStream.parse_variant_playlist)
mapper.map("flash", self._create_streams, "HDS",
HDSStream.parse_manifest)
return mapper(videos)
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
self.logger.debug("Matched URL: channel={0}, media_id={1}".format(
channel, media_id))
if not media_id:
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
if livestream.get("media_hosted_media"):
hosted = _live_schema.validate(
livestream["media_hosted_media"])
self.logger.info("{0} is hosting {1}",
livestream["media_user_name"],
hosted["media_user_name"])
livestream = hosted
if not livestream["media_is_live"]:
return
media_id = livestream["media_id"]
media_type = "live"
else:
media_type = "video"
res = http.get(PLAYER_API.format(media_type, media_id))
player = http.json(res, schema=_player_schema)
if media_type == "live":
return self._get_live_streams(player)
else:
return self._get_video_streams(player)
def _get_streams(self):
zdf_json = http.get(self.url, schema=_api_schema)
if zdf_json is None:
return
headers = {
"Api-Auth": "Bearer {0}".format(zdf_json['apiToken']),
"Referer": self.url
}
res = http.get(zdf_json['content'], headers=headers)
document = http.json(res, schema=_documents_schema)
stream_request_url = document["mainVideoContent"][
"http://zdf.de/rels/target"]["http://zdf.de/rels/streams/ptmd"]
stream_request_url = API_URL + stream_request_url
res = http.get(stream_request_url, headers=headers)
res = http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
def _get_qq_streams(self, vid):
res = http.get(QQ_STREAM_INFO_URL % (vid, 1))
info = http.json(res, schema=_qq_schema)
yield "live", HTTPStream(self.session, info)
res = http.get(QQ_STREAM_INFO_URL % (vid, 2))
info = http.json(res, schema=_qq_schema)
yield "live", HLSStream(self.session, info)
def _get_live_streams(self, subdomain):
"""
Get the live stream in a particular language
:param subdomain:
:return:
"""
res = http.get(self._live_api_url.format(subdomain))
live_res = http.json(res, schema=self._live_schema)
api_res = http.get(live_res[u"url"])
stream_data = http.json(api_res, schema=self._stream_api_schema)
return HLSStream.parse_variant_playlist(self.session,
stream_data[u'primary'])
def _get_streams(self):
match = _url_re.match(self.url)
username = match.group("username")
CSRFToken = str(uuid.uuid4().hex.upper()[0:32])
headers = {
"Content-Type": "application/x-www-form-urlencoded",
"X-CSRFToken": CSRFToken,
"X-Requested-With": "XMLHttpRequest",
"Referer": self.url,
}
cookies = {
"csrftoken": CSRFToken,
}
post_data = "room_slug={0}&bandwidth=high".format(username)
res = http.post(API_HLS, headers=headers, cookies=cookies, data=post_data)
data = http.json(res, schema=_post_schema)
if data["success"] is True and data["room_status"] == "public":
for s in HLSStream.parse_variant_playlist(self.session, data["url"]).items():
yield s
def _get_live_streams(self, slug):
res = http.get(LIVE_CHANNELS_API_URL)
res = http.json(res, schema=_channels_schema)
for channel in filter(lambda c: c["Slug"] == slug, res):
servers = channel["StreamingServers"]
return self._parse_streaming_servers(servers)
def _watch_live(self, channel, cookies):
self.logger.debug('_watch_live ... Channel: {0}'.format(channel))
watch_url = self.API_WATCH.format(self.base_url)
channels_url = self.API_CHANNELS.format(self.base_url, self._session_attributes.get('power_guide_hash'))
res = http.get(channels_url, headers=self.headers, cookies=cookies)
data = http.json(res, schema=self._channels_schema)
c_list = []
for d in data:
for c in d['channels']:
c_list.append(c)
cid = []
zattoo_list = []
for c in c_list:
zattoo_list.append(c['display_alias'])
if c['display_alias'] == channel:
cid = c['cid']
self.logger.debug('Available zattoo channels in this country: {0}'.format(', '.join(sorted(zattoo_list))))
if not cid:
cid = channel
self.logger.debug('CHANNEL ID: {0}'.format(cid))
params = {
'cid': cid,
'https_watch_urls': True,
'stream_type': 'hls'
}
return params, watch_url
def _post_api(self, api, payload, schema):
res = http.post(api, json=payload)
data = http.json(res, schema=schema)
if data["result"] == "success":
post_data = data["reply"]
return post_data
def _get_vod_stream(self):
vod_url = self.url
if vod_url.endswith('/'):
vod_url = vod_url[:-1]
json_url = '{0}.securevideo.json'.format(vod_url)
res = http.get(json_url)
match = _json_re.search(res.text)
if not match:
return
data = parse_json(match.group(1))
res = http.get(API_VOD.format(data['clientid'], data['mzid']))
data = http.json(res, schema=_stream_schema)
for d in data['targetUrls']:
if d['type'] == 'HDS':
hds_url = d['url']
for s in HDSStream.parse_manifest(self.session,
hds_url).items():
yield s
if d['type'] == 'HLS':
hls_url = d['url']
for s in HLSStream.parse_variant_playlist(
self.session, hls_url).items():
yield s
def _get_streams_from_media(self, media_id):
res = http.get(STREAM_INFO_URL.format(media_id), cookies=COOKIES)
media = http.json(res, schema=_media_schema)
params = extra_params = swf_url = message = None
for __ in media:
for __ in __["layerList"]:
for __ in __.get("sequenceList", []):
for layer in __["layerList"]:
name = layer["name"]
if name == "video":
params = layer.get("param")
elif name == "reporting":
extra_params = layer.get("param", {})
extra_params = extra_params.get("extraParams", {})
elif name == "message":
message = layer.get("param")
if not params:
self.logger.error(message.get("title"))
return []
if extra_params:
swf_url = extra_params.get("videoSwfURL")
mode = params.get("mode")
if mode == "live":
return self._get_live_streams(params, swf_url)
elif mode == "vod":
return self._get_vod_streams(params)
def _get_streams(self):
headers = {"Referer": self.url, "User-Agent": useragents.FIREFOX}
res = http.get(self.url, headers=headers)
m = self._playlist_re.search(res.text)
if not m:
return
res = http.get(m.group("url"), headers=headers)
if not res.text.startswith("#EXTM3U"):
hls_url = http.json(res).get("redir")
else:
hls_url = m.group("url")
if hls_url is not None:
self.logger.debug("HLS URL: {0}".format(hls_url))
streams = HLSStream.parse_variant_playlist(self.session,
hls_url,
headers=headers)
if not streams:
return {
"live": HLSStream(self.session, hls_url, headers=headers)
}
else:
return streams
def _get_channel_id(self, domain):
channel_info = http.get(CHANNEL_INFO_URL % str(domain))
info = http.json(channel_info, schema=_channel_schema)
if info is None:
return 0, 0
return info['channel']['vid'], info['channel']['id']
def _get_streams(self):
headers = {"User-Agent": useragents.FIREFOX, "Referer": self.url}
res = http.get(self.url, headers=headers)
files = self._files_re.findall(res.text)
if files is None:
return
files = list(set(files))
for url in files:
if ".m3u8" in url:
if url.startswith("https://weltmediathek-vh."):
url = "https://www.welt.de/video/services/token/{0}".format(
quote(url, safe=""))
res = http.get(url, headers=headers)
r_json = http.json(res)
url = r_json["urlWithToken"]
for s in HLSStream.parse_variant_playlist(
self.session, url, headers=headers).items():
yield s
elif url.endswith(".mp4"):
m = self._mp4_bitrate_re.search(url)
bitrate = m.group("bitrate")
if bitrate:
name = "{0}k".format(bitrate)
else:
name = "mp4"
yield name, HTTPStream(self.session, url, headers=headers)
def _get_stream_info(self, broadcast, quality, cdn, rmd):
params = {
"return_type": cdn,
"broad_key": "{broadcast}-flash-{quality}-hls".format(**locals())
}
res = http.get(STREAM_INFO_URLS.format(rmd=rmd), params=params)
return http.json(res, schema=_stream_schema)
def _get_streams(self):
asset_id = self._get_prid(self.get_option("subtitles"))
if asset_id:
self.logger.debug("Found asset id: {0}", asset_id)
streams = self.api_call(asset_id,
params=dict(adaptive="yes",
token=self.token),
schema=self.streams_schema)
for stream in streams:
if stream["format"] in ("adaptive", "hls", "mp4"):
if stream["contentType"] == "url":
stream_url = stream["url"]
else:
# using type=json removes the javascript function wrapper
info_url = stream["url"].replace(
"type=jsonp", "type=json")
# find the actual stream URL
stream_url = http.json(http.get(info_url),
schema=self.stream_info_schema)
if stream["format"] in ("adaptive", "hls"):
for s in HLSStream.parse_variant_playlist(
self.session, stream_url).items():
yield s
elif stream["format"] in ("mp3", "mp4"):
yield "vod", HTTPStream(self.session, stream_url)
def _get_vod_streams(self, params):
manifest_url = params.get("autoURL")
if not manifest_url:
return
res = http.get(manifest_url)
if res.headers.get("Content-Type") == "application/f4m+xml":
streams = HDSStream.parse_manifest(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
elif res.headers.get(
"Content-Type") == "application/vnd.apple.mpegurl":
streams = HLSStream.parse_variant_playlist(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
else:
manifest = http.json(res, schema=_vod_manifest_schema)
for params in manifest["alternates"]:
name = "{0}p".format(params["height"])
stream = self._create_flv_playlist(params["template"])
yield name, stream
failovers = params.get("failover", [])
for failover in failovers:
stream = self._create_flv_playlist(failover)
yield name, stream
def _login(self, email, password, _hello):
self.logger.debug('_login ... Attempting login as {0}'.format(email))
login_url = self.API_LOGIN.format(self.base_url)
params = {'login': email, 'password': password, 'remember': 'true'}
res = http.post(login_url,
headers=self.headers,
data=params,
cookies=_hello.cookies)
data = http.json(res)
self._authed = data['success']
if self._authed:
self.logger.debug('New Session Data')
self._session_attributes.set('beaker.session.id',
res.cookies.get('beaker.session.id'),
expires=3600 * 24)
self._session_attributes.set('pzuid',
res.cookies.get('pzuid'),
expires=3600 * 24)
self._session_attributes.set('power_guide_hash',
data['session']['power_guide_hash'],
expires=3600 * 24)
return self._authed
else:
return None
def _get_streams(self):
http.headers.update({
"User-Agent": useragents.CHROME,
"Referer": self.referer
})
fragment = dict(parse_qsl(urlparse(self.url).fragment))
link = fragment.get("link")
if not link:
link = self._get_tv_link()
if not link:
self.logger.error("Missing link fragment: stream unavailable")
return
player_url = self._api_url.format(link)
self.logger.debug("Requesting player API: {0} (referer={1})",
player_url, self.referer)
res = http.get(player_url,
params={"_": int(time.time() * 1000)},
headers={"X-Requested-With": "XMLHttpRequest"})
try:
data = http.json(res, schema=self.api_schema)
except PluginError as e:
print(e)
self.logger.error("Cannot play this stream type")
else:
if data["status"]:
if data["file"].startswith("<"):
self.logger.error("Cannot play embedded streams")
else:
return HLSStream.parse_variant_playlist(
self.session, data["file"])
else:
self.logger.error(data["text"])
def _get_streams(self):
m_url = self._url_re.match(self.url)
host = m_url.group('host')
id_url = m_url.group('id')
api_url = self._api_url.format(host)
headers = {'User-Agent': useragents.FIREFOX}
res = http.get(self.url, headers=headers)
m = self._videoid_re.search(res.text)
if m:
video_id = m.group('id')
else:
http.get('{0}/token'.format(api_url), params={'realm': host.replace('.', '')})
headers2 = {
'User-Agent': useragents.FIREFOX,
'Referer': self.url,
'x-disco-client': 'WEB:UNKNOWN:dplay-client:0.0.1'
}
try:
res = http.get('{0}/content/videos/{1}'.format(api_url, id_url), headers=headers2)
except Exception as e:
if '404' in str(e):
self.logger.error('No video found on this url.')
return
data = http.json(res)
if data:
video_id = data['data']['id']
if not video_id:
self.logger.error('Found no video id')
return
res = http.get('{0}/playback/videoPlaybackInfo/{1}'.format(api_url, video_id), headers=headers)
data = http.json(res, schema=_api_schema)
if not data:
return
hls_url = data['hls']['url']
streams = HLSStream.parse_variant_playlist(self.session, hls_url, headers=headers)
if not streams:
return {'live': HLSStream(self.session, hls_url, headers=headers)}
else:
return streams
def _get_streams(self):
# Get video ID and channel from URL
match = self._url_re.match(self.url)
video_id = match.group('video_id')
if video_id is None:
# Retrieve URL page and search for video ID
res = http.get(self.url)
match = self._video_id_re.search(res.text)
if match is None:
return
video_id = match.group('video_id')
res = http.get(self.API_URL.format(video_id))
videos = http.json(res, schema=self._api_schema)
parsed = []
headers = {'User-Agent': self._user_agent}
# Some videos may be also available on Dailymotion (especially on CNews)
if videos['ID_DM'] != '':
for stream in self.session.streams('https://www.dailymotion.com/video/' + videos['ID_DM']).items():
yield stream
for quality, video_url in list(videos['MEDIA']['VIDEOS'].items()):
# Ignore empty URLs
if video_url == '':
continue
# Ignore duplicate video URLs
if video_url in parsed:
continue
parsed.append(video_url)
try:
# HDS streams don't seem to work for live videos
if '.f4m' in video_url and 'LIVE' not in videos['TYPE']:
for stream in HDSStream.parse_manifest(self.session,
video_url,
params={'hdcore': self.HDCORE_VERSION},
headers=headers).items():
yield stream
elif '.m3u8' in video_url:
for stream in HLSStream.parse_variant_playlist(self.session,
video_url,
headers=headers).items():
yield stream
elif '.mp4' in video_url:
# Get bitrate from video filename
match = self._mp4_bitrate_re.match(video_url)
if match is not None:
bitrate = match.group('bitrate')
else:
bitrate = quality
yield bitrate, HTTPStream(self.session,
video_url,
params={'secret': self.SECRET},
headers=headers)
except IOError as err:
if '403 Client Error' in str(err):
self.logger.error('Failed to access stream, may be due to geo-restriction')
def _get_streams(self):
channel = self.url_re.match(self.url).group(1)
res = http.get(self.api_url.format(channel))
data = http.json(res, schema=self.api_schema)
return HLSStream.parse_variant_playlist(self.session,
data["channel_stream_url"])
def _get_vod_streams(self):
page = http.get(self.url)
asset = re.search(r'asse_.{32}', str(page._content)).group(0)
post_data = '{"asset_url":"/api/assets/%s/"}' % asset
stream_data = http.json(
http.post(self._stream_get_url,
data=post_data))['objects'][0]['level3']['streaming_url']
return HLSStream.parse_variant_playlist(self.session, stream_data)
def _get_live_streams(self, lang, path):
"""
Get the live stream in a particular language
:param lang:
:param path:
:return:
"""
res = http.get(self._live_api_url.format(lang, path))
live_res = http.json(res)['default']['uid']
post_data = '{"channel_url":"/api/channels/%s/"}' % live_res
try:
stream_data = http.json(
http.post(self._stream_get_url, data=post_data))['stream_url']
except BaseException:
stream_data = http.json(
http.post(self._stream_get_url, data=post_data))['channel_url']
return HLSStream.parse_variant_playlist(self.session, stream_data)
def _get_vod_stream(self, vod_id):
res = self._get_api_res("recordings", vod_id)
for sdata in http.json(res, schema=self._vod_schema):
if sdata["format"] == "hls":
hls_url = urljoin(sdata["url"], "manifest.m3u8")
yield "{0}p".format(sdata["height"]), HLSStream(
self.session, hls_url)
def _get_streams(self):
"""
Get the config object from the page source and call the
API to get the list of streams
:return:
"""
# attempt a login
self.login()
res = http.get(self.url)
# decode the config for the page
matches = self.config_re.finditer(res.text)
try:
config = self.config_schema.validate(
dict([m.group("key", "value") for m in matches]))
except PluginError:
return
if config["selectedVideoHID"]:
self.logger.debug("Found video hash ID: {0}",
config["selectedVideoHID"])
api_url = urljoin(
self.url,
urljoin(config["videosURL"], config["selectedVideoHID"]))
elif config["livestreamURL"]:
self.logger.debug("Found live stream URL: {0}",
config["livestreamURL"])
api_url = urljoin(self.url, config["livestreamURL"])
else:
return
ares = http.get(api_url)
data = http.json(ares, schema=self.api_schema)
viewing_urls = data["viewing_urls"]
if "error" in viewing_urls:
self.logger.error("Failed to load streams: {0}",
viewing_urls["error"])
else:
for url in viewing_urls["urls"]:
try:
label = "{0}p".format(url.get("res", url["label"]))
except KeyError:
label = "live"
if url["type"] == "rtmp/mp4" and RTMPStream.is_usable(
self.session):
params = {
"rtmp": url["src"],
"pageUrl": self.url,
"live": True,
}
yield label, RTMPStream(self.session, params)
elif url["type"] == "application/x-mpegURL":
for s in HLSStream.parse_variant_playlist(
self.session, url["src"]).items():
yield s
def _get_streams(self):
# fetch requested url and find playlist info
response = http.get(self.url)
info = _find_playlist_info(response)
if not info:
# playlist info not found, let's try to find player url
player_url = _find_player_url(response)
if not player_url:
raise PluginError('Cannot find playlist info or player url!')
# get player url and try to find playlist info in it
response = http.get(player_url)
info = _find_playlist_info(response)
if not info:
raise PluginError(
'Cannot find playlist info in the player url!')
data = {
'playlist[0][type]': info['type'],
'playlist[0][id]': info['id'],
'requestUrl': '/ivysilani/embed/iFramePlayerCT24.php',
'requestSource': 'iVysilani',
'type': 'html'
}
headers = {
'x-addr': '127.0.0.1',
}
# fetch playlist url
response = http.post(
'http://www.ceskatelevize.cz/ivysilani/ajax/get-client-playlist',
data=data,
headers=headers)
json_data = http.json(response, schema=_playlist_url_schema)
if json_data['url'] == "error_region":
self.logger.error("This stream is not available in your territory")
return
# fetch playlist
response = http.post(json_data['url'])
json_data = http.json(response, schema=_playlist_schema)
playlist = json_data['playlist'][0]['streamUrls']['main']
return HLSStream.parse_variant_playlist(self.session, playlist)
def _get_plu_streams(self, cid):
res = http.get(PLU_STREAM_INFO_URL % cid)
info = http.json(res, schema=_plu_schema)
for source in info["playLines"][0]["urls"]:
quality = self._get_quality(source["resolution"])
if source["ext"] == "m3u8":
yield quality, HLSStream(self.session, source["securityUrl"])
elif source["ext"] == "flv":
yield quality, HTTPStream(self.session, source["securityUrl"])
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search(r"embed.swf\?p=(\d+)", res.text)
if not match:
return
program = match.group(1)
res = http.get(BEAT_PROGRAM.format(program), headers=HEADERS)
return http.json(res, schema=_schema)
def _get_streams(self):
res = http.get(DATA_URL)
data = http.json(res, schema=_data_schema)
video_id = data["channel"] or data["channel2"]
if not video_id:
return
url = "http://youtu.be/{0}".format(video_id)
return self.session.streams(url)
