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):
# Discover root
match = _url_re.search(self.url)
root = match.group(1)
# Download main URL
res = http.get(self.url)
# Find playlist
match = _playlist_re.search(res.text)
playlist_url = root + match.group(1) + "d"
# Download playlist
res = http.get(playlist_url)
# Find manifest
match = _manifest_re.search(res.text)
manifest_url = match.group(1)
# Find SWF
match = _swf_re.search(res.text)
swf_url = match.group(1)
streams = {}
streams.update(
HDSStream.parse_manifest(self.session, manifest_url,
pvswf=swf_url))
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_streams(self):
res = http.get(self.url)
match = _player_js.search(res.text)
if match:
player_js = match.group(0)
self.logger.info("Found player js {0}", player_js)
else:
self.logger.info(
"Didn't find player js. Probably this page doesn't contain a video"
)
return
res = http.get(player_js)
jsonp_start = res.text.find('(') + 1
jsonp_end = res.text.rfind(')')
if jsonp_start <= 0 or jsonp_end <= 0:
self.logger.info(
"Couldn't extract json metadata from player.js: {0}",
player_js)
return
json_s = res.text[jsonp_start:jsonp_end]
stream_metadata = json.loads(json_s)
return HDSStream.parse_manifest(
self.session,
stream_metadata['mediaResource']['dflt']['videoURL']).items()
def _get_streams(self):
match = _url_re.match(self.url)
videoid = match.group('id')
streams = {}
# Set header data for user-agent
hdr = {'User-Agent': USER_AGENT}
# Parse video ID from data received from supplied URL
res = http.get(VK_VIDEO_URL + videoid.strip(), headers=hdr)
for match in re.findall(SINGLE_VIDEO_URL, res.text):
url = match[0].replace("\\/", "/")
streams[match[2]] = HTTPStream(self.session, url)
if not streams:
# try to check is live
match = VK_LIVE_HASH.search(res.text)
params = videoid.split('_')
if match and match.group('hash'):
url = VK_EXT_URL.format(params[0].replace('video', "").replace('-', ""), params[1], match.group('hash'))
res = http.get(url, headers=hdr)
match = SINGLE_HLS_URL.search(res.text)
if match and match.group('playlist'):
hls_streams = HLSStream.parse_variant_playlist(self.session, match.group('playlist').replace("\\/", "/"), namekey="pixels")
streams.update(hls_streams)
return streams
def _get_streams(self):
match = _url_re.match(self.url)
videoid = match.group('id')
# Set header data for user-agent
hdr = {'User-Agent': USER_AGENT}
# Parse video ID from data received from supplied URL
res = http.get(self.url, headers=hdr)
if not res:
return {}
for match in re.findall(_player_params, res.text):
try:
params = json.loads(base64.b64decode(match))
video_url = params.get("url")
res = http.get(video_url, headers=hdr)
video_url = res.text.split('=')[1]
return HLSStream.parse_variant_playlist(
self.session, video_url)
except Exception as e:
self.logger.error("Failed to decode player params: {0}", e)
return {}
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_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_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_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):
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_meta(self):
html = http.get('http://www.npo.nl/live/{}'.format(self.npo_id),
headers=HTTP_HEADERS).text
program_id = re.compile('data-prid="(.*?)"', re.DOTALL +
re.IGNORECASE).search(html).group(1)
meta = http.get('http://e.omroep.nl/metadata/{}'.format(program_id),
headers=HTTP_HEADERS).text
meta = re.compile('({.*})',
re.DOTALL + re.IGNORECASE).search(meta).group(1)
return json.loads(meta)
def _get_live_streams(self):
meta = self._get_meta()
stream = [x for x in meta['streams'] if x['type'] == 'hls'][0]['url']
url = 'http://ida.omroep.nl/aapi/?type=jsonp&stream={}&token={}'.format(
stream, self.get_token())
streamdata = http.get(url, headers=HTTP_HEADERS).json()
deeplink = http.get(streamdata['stream'], headers=HTTP_HEADERS).text
deeplink = re.compile('"(.*?)"', re.DOTALL +
re.IGNORECASE).search(deeplink).group(1)
playlist_url = deeplink.replace("\\/", "/")
return HLSStream.parse_variant_playlist(self.session, playlist_url)
def _get_streams(self):
res = http.get(self.url)
match = _meta_xmlurl_id_re.search(res.text)
if not match:
return
xml_info_url = STREAMS_INFO_URL.format(match.group(1))
video_info_res = http.get(xml_info_url)
parsed_info = http.xml(video_info_res)
live_el = parsed_info.find("live")
live = live_el is not None and live_el.text == "1"
streams = {}
hdsurl_el = parsed_info.find("hdsurl")
if hdsurl_el is not None and hdsurl_el.text is not None:
hdsurl = hdsurl_el.text
streams.update(HDSStream.parse_manifest(self.session, hdsurl))
if live:
vurls_el = parsed_info.find("vurls")
if vurls_el is not None:
for i, vurl_el in enumerate(vurls_el):
bitrate = vurl_el.get("bitrate")
name = bitrate + "k" if bitrate is not None else "rtmp{0}".format(
i)
params = {
"rtmp": vurl_el.text,
}
streams[name] = RTMPStream(self.session, params)
parsed_urls = set()
mobileurls_el = parsed_info.find("mobileurls")
if mobileurls_el is not None:
for mobileurl_el in mobileurls_el:
text = mobileurl_el.text
if not text:
continue
if text in parsed_urls:
continue
parsed_urls.add(text)
url = urlparse(text)
if url[0] == "http" and url[2].endswith("m3u8"):
streams.update(
HLSStream.parse_variant_playlist(self.session, text))
return streams
def _get_vod_streams(self):
url = 'http://ida.omroep.nl/odi/?prid={}&puboptions=adaptive,h264_bb,h264_sb,h264_std&adaptive=no&part=1&token={}'\
.format(quote(self.npo_id), quote(self.get_token()))
res = http.get(url, headers=HTTP_HEADERS)
data = res.json()
streams = {}
stream = http.get(data['streams'][0].replace('jsonp', 'json'),
headers=HTTP_HEADERS).json()
streams['best'] = streams['high'] = HTTPStream(self.session,
stream['url'])
return streams
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_playlist_url(self):
# get the id
content = http.get(self.url)
match = _id_re.match(content.text.replace("\n", ""))
if not match:
return
# get the m3u8 file url
player_url = _stream_player_url.format(match.group(1))
content = http.get(player_url)
match = _file_re.match(content.text.replace("\n", ""))
if match:
return match.group(1)
def _get_streams(self):
vid = self.url_re.match(self.url).group(1)
self.logger.debug("Found video ID: {}", vid)
page = http.get(self.play_url.format(vid=vid))
js_url_m = self.js_re.search(page.text)
if js_url_m:
js_url = js_url_m.group(1)
self.logger.debug("Loading player JS: {}", js_url)
res = http.get(js_url)
data = self.setup_schema.validate(res.text)
for source in data["playlist"][0]["sources"]:
if source["type"] == "hls":
return HLSStream.parse_variant_playlist(self.session, "https:" + source["file"])
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_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 _get_live_streams(self, params, swf_url):
for key, quality in QUALITY_MAP.items():
key_url = "{0}URL".format(key)
url = params.get(key_url)
if not url:
continue
try:
res = http.get(url, exception=IOError)
except IOError:
continue
if quality == "hds":
streams = HDSStream.parse_manifest(self.session, res.url)
for name, stream in streams.items():
if key == "source":
name += "+"
yield name, stream
elif res.text.startswith("rtmp"):
match = _rtmp_re.match(res.text)
if not match:
continue
stream = RTMPStream(
self.session, {
"rtmp": match.group("host"),
"app": match.group("app"),
"playpath": match.group("playpath"),
"swfVfy": swf_url,
"live": True
})
yield quality, stream
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_swf_url(self):
res = http.get(self.url)
match = _swf_url_re.search(res.text)
if not match:
raise PluginError("Unable to find SWF URL in the HTML")
return match.group(1)
def _get_sarpurinn_streams(self):
res = http.get(self.url)
match = _rtmp_url_re.search(res.text)
if not match:
yield
token = match.group("id")
status = match.group("status")
extension = match.group("ext")
date = match.group("date")
if not date:
date = ""
if extension == "mp3":
key = "audio"
else:
key = "576p"
# HLS on Sarpurinn is currently only available on videos
yield key, HLSStream(
self.session,
HLS_SARPURINN_URL.format(status, date, token, extension))
yield key, RTMPStream(
self.session, {
"rtmp": RTMP_SARPURINN_URL.format(status, date, token,
extension),
"pageUrl": self.url,
"live": True
})
def _get_streams(self):
res = http.get(self.url)
match = _embed_re.search(res.text)
if match:
url = match.group(1)
return self.session.streams(url)
def _get_streams(self):
res = http.get(self.url)
data_m = self.data_re.search(res.text)
if data_m:
stream_url = data_m.group(1)
self.logger.debug("Found stream: {}", stream_url)
yield "live", HLSStream(self.session, stream_url)
def _get_streams(self):
"""
Find the streams for web.tv
:return:
"""
headers = {}
res = http.get(self.url, headers=headers)
headers["Referer"] = self.url
sources = self._sources_re.findall(res.text)
if len(sources):
sdata = parse_json(sources[0], schema=self._sources_schema)
for source in sdata:
self.logger.debug("Found stream of type: {}", source[u'type'])
if source[u'type'] == u"application/vnd.apple.mpegurl":
# if the url has no protocol, assume it is http
url = source[u"src"]
if url.startswith("//"):
url = "http:" + url
try:
# try to parse the stream as a variant playlist
variant = HLSStream.parse_variant_playlist(self.session, url, headers=headers)
if variant:
for q, s in variant.items():
yield q, s
else:
# and if that fails, try it as a plain HLS stream
yield 'live', HLSStream(self.session, url, headers=headers)
except IOError:
self.logger.warning("Could not open the stream, perhaps the channel is offline")
def _get_streams(self):
if _stream_url_re.match(self.url):
mode = MODE_STREAM
else:
mode = MODE_VOD
res = http.get(self.url)
match = _json_re.search(res.text)
if match:
data = json.loads(
_json_re.search(res.text).group('json').replace('"', '"'))
else:
raise PluginError("Could not extract JSON metadata")
streams = {}
try:
if mode == MODE_STREAM:
sources = data['playlist']['videos'][0]['sources']
elif mode == MODE_VOD:
sources = data['selected_video']['sources']
except (KeyError, IndexError):
raise PluginError("Could not extract sources")
for source in sources:
try:
if source['delivery'] != 'hls':
continue
url = source['src'].replace('\/', '/')
except KeyError:
continue
stream = HLSStream.parse_variant_playlist(self.session, url)
streams.update(stream)
return streams
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
res = http.get(ASSET_URL.format(video_id))
assets = http.xml(res, schema=_asset_schema)
streams = {}
for asset in assets:
base = asset["base"]
url = asset["url"]
if urlparse(url).path.endswith(".f4m"):
streams.update(
HDSStream.parse_manifest(self.session, url, pvswf=SWF_URL)
)
elif base.startswith("rtmp"):
name = "{0}k".format(asset["bitrate"])
params = {
"rtmp": asset["base"],
"playpath": url,
"live": True
}
streams[name] = RTMPStream(self.session, params)
return streams
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)
