def _get_streams(self):
match = _url_re.match(self.url)
title = self.url.rsplit('/', 1)[-1]
if title.endswith(".html"):
title = title[:-5]
request_url = "https://api.zdf.de/content/documents/%s.json?profile=player" % title
res = http.get(request_url,
headers={
"Api-Auth":
"Bearer d2726b6c8c655e42b68b0db26131b15b22bd1a32"
})
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)
res = http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
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_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_http", HLSStream(self.session, info)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
http.headers.update({'User-Agent': USER_AGENT})
http.verify = False
http.mount('https://', HTTPAdapter(max_retries=99))
#Thanks to @ximellon for providing method.
try:
channel = int(channel)
except ValueError:
channel = http.get(self.url, schema=_room_id_schema)
if channel == 0:
channel = http.get(self.url, schema=_room_id_alt_schema)
res = http.get(MAPI_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
return
if room["show_status"] != SHOW_STATUS_ONLINE:
return
ts = int(time.time() / 60)
did = uuid.uuid4().hex.upper()
sign = hashlib.md5(
("{0}{1}{2}{3}".format(channel, did, LAPI_SECRET,
ts)).encode("utf-8")).hexdigest()
data = {"cdn": "ws", "rate": "0", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "source", stream
data = {"cdn": "ws", "rate": "2", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "middle", stream
data = {"cdn": "ws", "rate": "1", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "low", stream
def _get_live_streams(self, language):
"""
Get the live stream in a particular language
:param language:
:return:
"""
res = http.get(self._live_api_url)
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)
# find the stream in the requested language
if language in stream_data[u'primary']:
playlist_url = stream_data[u'primary'][language][u"hls"]
return HLSStream.parse_variant_playlist(self.session, playlist_url)
def _get_streams(self):
flashvars = http.get(self.url, schema=_flashvars_schema)
if not flashvars:
return
params = {
"rt": "json",
"lc": "en_US",
"pt": "view",
"bpw": "",
"bid": flashvars["id"],
"adok": "",
"bno": ""
}
if re.search(_url_re_tw, self.url):
res = http.get(VIEW_LIVE_API_URL_TW, params=params)
elif re.search(_url_re_jp, self.url):
res = http.get(VIEW_LIVE_API_URL_JP, params=params)
else:
res = http.get(VIEW_LIVE_API_URL, params=params)
streams = http.json(res, schema=_view_live_schema)
for stream in streams:
stream_name = "{0}p".format(stream["bps"])
stream_params = {"rtmp": stream["purl"], "live": True}
yield stream_name, RTMPStream(self.session, stream_params)
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 = 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", {})
if not params:
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):
# get the page
res = http.get(self.url, headers={"User-Agent": self._user_agent})
# find the big blob of stream info in the page
stream_data = self._stream_data_re.match(res.text)
stream_name = AdultSwim._url_re.match(
self.url).group(1) or "live-stream"
if stream_data:
# parse the stream info as json
stream_info = parse_json(stream_data.group(1),
schema=self._page_data_schema)
# get the stream ID
stream_id = stream_info[u"streams"][stream_name][u"stream"]
if stream_id:
api_url = self.API_URL.format(id=stream_id)
res = http.get(api_url,
headers={"User-Agent": self._user_agent})
stream_data = http.json(res, schema=self._api_schema)
for asset in stream_data[u'data'][u'stream'][u'assets']:
for n, s in HLSStream.parse_variant_playlist(
self.session, asset[u"url"]).items():
yield n, s
else:
self.logger.error(
"Couldn't find the stream ID for this stream: {}".format(
stream_name))
else:
self.logger.error(
"Couldn't find the stream data for this stream: {}".format(
stream_name))
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 _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_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 _authenticate(self, email, password):
csrf_token = http.get(LOGIN_PAGE_URL, schema=_csrf_token_schema)
if not csrf_token:
raise PluginError("Unable to find CSRF token")
data = {
"authenticity_token": csrf_token,
"channel_id": "",
"commit": "Login",
"plan_id": "",
"session[email]": email,
"session[password]": password,
"utf8": "\xE2\x9C\x93", # Check Mark Character
}
res = http.post(LOGIN_POST_URL,
data=data,
acceptable_status=(200, 422))
result = http.json(res, schema=_login_schema)
errors = result.get("errors")
if errors:
errors = ", ".join(errors)
raise PluginError("Unable to authenticate: {0}".format(errors))
self.logger.info("Successfully logged in as {0}", result["email"])
def _get_streams(self):
self.url = http.resolve_url(self.url)
match = _url_re.match(self.url)
parsed = urlparse(self.url)
if parsed.fragment:
channel_id = parsed.fragment
elif parsed.path[:3] == '/v/':
channel_id = parsed.path.split('/')[-1]
else:
channel_id = match.group("channel")
if not channel_id:
return
channel_id = channel_id.lower().replace("/", "_")
res = http.get(API_URL.format(channel_id))
info = http.json(res, schema=_schema)
if not info["success"]:
return
if info.get("isLive"):
name = "live"
else:
name = "vod"
stream = HTTPStream(self.session, info["payload"])
# Wrap the stream in a FLVPlaylist to verify the FLV tags
stream = FLVPlaylist(self.session, [stream])
return {name: stream}
def _get_star_streams(self, desktop_url, mobile_url, token=""):
if token:
self.logger.debug("Opening stream with token: {}", token)
if mobile_url:
for _, s in HLSStream.parse_variant_playlist(self.session,
mobile_url + token,
headers={
"Referer":
self.url
}).items():
yield "live", s
if desktop_url:
# get the HDS stream URL
res = http.get(desktop_url + token)
stream_data = http.json(res, schema=self.hds_schema)
for _, s in HDSStream.parse_manifest(
self.session,
stream_data["url"],
pvswf=self.SWF_URL,
is_akamai=stream_data["use_akamai"],
headers={
"Referer": self.url
}).items():
yield "live", s
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, movie_id):
for stream_type in STREAM_TYPES:
cookies = {"flash-player-type": stream_type}
res = ajax(VODINFO_URL.format(movie_id), cookies=cookies)
vod = http.json(res, schema=_vod_schema)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._parse_vod_streams(vod):
yield stream
def get_json(url):
"""Fetch page for given URL and return json Python object.
:param url: URL to fetch
"""
res = http.get(url)
return http.json(res)
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search("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)
def _get_live_streams(self, channel_id):
params = {"channel_id": channel_id}
for stream_type in STREAM_TYPES:
cookies = {"flash-player-type": stream_type}
res = ajax(CHINFO_URL, cookies=cookies, data=params)
channel = http.json(res, schema=_channel_schema)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._parse_live_streams(channel):
yield stream
def _get_stream_info(self, broadcast, type):
params = {
"return_type": "gs_cdn",
"use_cors": "true",
"cors_origin_url": "m.afreeca.com",
"broad_no": "{broadcast}-mobile-hd-{type}".format(**locals()),
"broad_key": "{broadcast}-flash-hd-{type}".format(**locals())
}
res = http.get(STREAM_INFO_URLS[type], params=params)
return http.json(res, schema=_stream_schema)
def _get_vod_streams(self, name):
res = http.get(API_URL.format("videos", name))
json = http.json(res, schema=_vod_schema)
if not json:
return
streams = {}
streams["source"] = self._create_rtmp_stream(
VOD_RTMP_URL.format(json["channel_slug"]), json["name"], True)
return streams
def _get_streams(self):
match = self._url_re.match(self.url)
film_id, episode_id = match.groups()
headers = {"Referer": self.url, "User-Agent": self._user_agent}
# Get the info about the Episode, including the Grabber API URL
info_res = http.get(self._episode_info_url,
params=dict(update=0, film=film_id, id=episode_id),
headers=headers)
info = http.json(info_res, schema=self._info_schema)
# Get the data about the streams from the Grabber API
stream_list_res = http.get(info["grabber"],
params=info["params"],
headers=headers)
stream_data = http.json(stream_list_res, schema=self._streams_schema)
for stream in stream_data["data"]:
yield stream["label"], HTTPStream(self.session, stream["file"])
def _get_live_streams(self, name):
res = http.get(API_URL.format("channels", name))
json = http.json(res, schema=_channel_schema)
if not json:
return
streams = {}
for quality in json["stream"]["qualities"]:
streams[self._get_quality(quality)] = self._create_rtmp_stream(
json["stream"]["rootUrl"], quality, True)
return streams
def _get_streams(self):
url_params = dict(parse_qsl(urlparse(self.url).query))
video_id = url_params.get("videoid")
if video_id:
self.logger.debug("Found Video ID: {}", video_id)
res = http.get(self.api_url.format(id=video_id))
data = http.json(res, schema=self.api_schema)
hls = self._make_stream(data["video_info"]["hlsvideosource"])
video = self._make_stream(data["video_info"]["videosource"])
if hls:
yield "live", hls
if video:
yield "live", video
def _get_channel_video(self, channel_id):
query = {
"channelId": channel_id,
"type": "video",
"eventType": "live",
"part": "id",
"key": API_KEY
}
res = http.get(API_SEARCH_URL, params=query)
videos = http.json(res, schema=_search_schema)
for video in videos:
video_id = video["id"]["videoId"]
return video_id
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["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"])
elif source["ext"] == "rtmp":
yield quality, RTMPStream(self.session, {
"rtmp": source["securityUrl"],
"live": True
})
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
if channel != "video":
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
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_hls_url(self, content_id):
# make the api url relative to the current domain
if "cnnturk" in self.url:
self.logger.debug("Using alternative content API url")
api_url = urljoin(self.url,
self.alt_content_api.format(id=content_id))
else:
api_url = urljoin(self.url, self.content_api.format(id=content_id))
apires = http.get(api_url)
stream_data = http.json(apires, schema=self.content_api_schema)
d = stream_data["Media"]["Link"]
return urljoin((d["ServiceUrl"] or d["DefaultServiceUrl"]),
d["SecurePath"])
def _get_streams(self):
res = http.get(self.url)
match = _embed_re.search(res.text)
if match:
res = http.get(match.group(1))
match = _aptoma_id_re.search(res.text)
if not match:
return
aptoma_id = match.group(1)
if not _live_re.search(res.text):
res = http.get(METADATA_URL.format(aptoma_id))
metadata = http.json(res)
video_id = metadata["videoId"]
else:
video_id = aptoma_id
res = http.get(VIDEO_INFO_URL, params=dict(id=video_id))
video = http.json(res, schema=_video_schema)
streams = {}
for fmt, providers in video["formats"].items():
for name, provider in providers.items():
for ext, playlists in provider.items():
for playlist in playlists:
url = PLAYLIST_URL_FORMAT.format(**playlist)
parser = STREAM_TYPES[fmt]
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.error(
"Failed to extract {0} streams: {1}",
fmt.upper(), err)
return streams
