def test_url_concat():
assert url_concat("http://test.se", "one", "two",
"three") == "http://test.se/one/two/three"
assert url_concat("http://test.se", "/one", "/two",
"/three") == "http://test.se/one/two/three"
assert url_concat("http://test.se/one", "../two",
"three") == "http://test.se/two/three"
assert url_concat("http://test.se/one", "../two",
"../three") == "http://test.se/three"
def test_url_concat(self):
self.assertEqual(url_concat("http://test.se", "one", "two", "three"),
"http://test.se/one/two/three")
self.assertEqual(
url_concat("http://test.se", "/one", "/two", "/three"),
"http://test.se/one/two/three")
self.assertEqual(url_concat("http://test.se/one", "../two", "three"),
"http://test.se/two/three")
self.assertEqual(
url_concat("http://test.se/one", "../two", "../three"),
"http://test.se/three")
def _get_streams(self):
zdf_json = self.session.http.get(self.url, schema=_api_schema)
if zdf_json is None:
return
headers = {
"Accept": "application/vnd.de.zdf.v1.0+json",
"Api-Auth": "Bearer {0}".format(zdf_json['apiToken']),
"Referer": self.url
}
res = self.session.http.get(zdf_json['content'], headers=headers)
document = self.session.http.json(res, schema=_documents_schema)
content = document["mainVideoContent"]
target = content["http://zdf.de/rels/target"]
template = target["http://zdf.de/rels/streams/ptmd-template"]
stream_request_url = url_concat(API_URL, template.format(playerId="ngplayer_2_3").replace(" ", ""))
res = self.session.http.get(stream_request_url, headers=headers)
res = self.session.http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
def _get_streams(self):
self.session.http.headers.update({
'Referer':
'http://www.abweb.com/BIS-TV-Online/bistvo-tele-universal.aspx'
})
login_username = self.get_option('username')
login_password = self.get_option('password')
if self.options.get('purge_credentials'):
self.clear_cookies()
self._authed = False
log.info('All credentials were successfully removed.')
if self._authed:
log.info('Attempting to authenticate using cached cookies')
elif not self._authed and not (login_username and login_password):
log.error(
'A login for ABweb is required, use --abweb-username USERNAME --abweb-password PASSWORD'
)
return
elif not self._authed and not self._login(login_username,
login_password):
return
log.debug('get iframe_url')
res = self.session.http.get(self.url)
for iframe in itertags(res.text, 'iframe'):
iframe_url = iframe.attributes.get('src')
if iframe_url.startswith('/'):
iframe_url = url_concat('https://www.abweb.com', iframe_url)
else:
iframe_url = update_scheme('https://', iframe_url)
log.debug('iframe_url={0}'.format(iframe_url))
break
else:
raise PluginError('No iframe_url found.')
self.session.http.headers.update({'Referer': iframe_url})
res = self.session.http.get(iframe_url)
m = self._hls_re.search(res.text)
if not m:
raise PluginError('No hls_url found.')
hls_url = update_scheme('https://', m.group('url'))
streams = HLSStream.parse_variant_playlist(self.session, hls_url)
if streams:
for stream in streams.items():
yield stream
else:
yield 'live', HLSStream(self.session, hls_url)
def _get_live_streams(self, channel_id):
# Get quality info and check if user is live1
data = self.session.http.get(
"https://cloudac.mildom.com/nonolive/gappserv/live/enterstudio",
params={
"__platform": "web",
"user_id": channel_id,
},
headers={"Accept-Language": "en"},
schema=validate.Schema(
validate.parse_json(),
{
"code": int,
validate.optional("message"): str,
validate.optional("body"): {
validate.optional("status"): int,
"anchor_live": int,
validate.optional("live_type"): int,
"ext": {
"cmode_params": [{
"cmode": str,
"name": str,
}],
validate.optional("live_mode"): int,
},
},
},
))
log.trace(f"{data!r}")
if data["code"] != 0:
log.debug(data.get("message", "Mildom API returned an error"))
return
if data["body"]["anchor_live"] != 11:
log.debug("User doesn't appear to be live")
return
qualities = []
for quality_info in data["body"]["ext"]["cmode_params"]:
qualities.append((quality_info["name"], "_" + quality_info["cmode"]
if quality_info["cmode"] != "raw" else ""))
# Get token
data = self.session.http.post(
"https://cloudac.mildom.com/nonolive/gappserv/live/token",
params={
"__platform": "web",
"__guest_id": "pc-gp-{}".format(uuid4()),
},
headers={"Accept-Language": "en"},
json={
"host_id": channel_id,
"type": "hls"
},
schema=validate.Schema(
validate.parse_json(), {
"code": int,
validate.optional("message"): str,
validate.optional("body"): {
"data": [{
"token": str,
}],
}
}))
log.trace(f"{data!r}")
if data["code"] != 0:
log.debug(data.get("message", "Mildom API returned an error"))
return
token = data["body"]["data"][0]["token"]
# Create stream URLs
data = self.session.http.get(
"https://cloudac.mildom.com/nonolive/gappserv/live/liveserver",
params={
"__platform": "web",
"user_id": channel_id,
"live_server_type": "hls",
},
headers={"Accept-Language": "en"},
schema=validate.Schema(
validate.parse_json(), {
"code": int,
validate.optional("message"): str,
validate.optional("body"): {
"stream_server": validate.url(),
}
}))
log.trace(f"{data!r}")
if data["code"] != 0:
log.debug(data.get("message", "Mildom API returned an error"))
return
base_url = url_concat(data["body"]["stream_server"],
f"{channel_id}{{}}.m3u8?{token}")
self.session.http.headers.update(
{"Referer": "https://www.mildom.com/"})
for quality in qualities:
yield quality[0], HLSStream(self.session,
base_url.format(quality[1]))
def _get_streams(self):
zdf_json = self.session.http.get(self.url, schema=validate.Schema(
validate.transform(self._re_api_json.search),
validate.any(None, validate.all(
validate.get("json"),
validate.transform(parse_json),
{
"apiToken": str,
"content": validate.url()
},
validate.union_get("apiToken", "content")
))
))
if zdf_json is None:
return
apiToken, apiUrl = zdf_json
headers = {
"Accept": "application/vnd.de.zdf.v1.0+json;charset=UTF-8",
"Api-Auth": f"Bearer {apiToken}",
"Referer": self.url
}
pApiUrl = urlparse(apiUrl)
apiUrlBase = urlunparse((pApiUrl.scheme, pApiUrl.netloc, "", "", "", ""))
apiUrlPath = self.session.http.get(apiUrl, headers=headers, schema=validate.Schema(
validate.transform(parse_json),
{"mainVideoContent": {
"http://zdf.de/rels/target": {
"http://zdf.de/rels/streams/ptmd-template": str
}
}},
validate.get(("mainVideoContent", "http://zdf.de/rels/target", "http://zdf.de/rels/streams/ptmd-template")),
validate.transform(lambda template: template.format(playerId=self.PLAYER_ID).replace(" ", ""))
))
stream_request_url = url_concat(apiUrlBase, apiUrlPath)
data = self.session.http.get(stream_request_url, headers=headers, schema=validate.Schema(
validate.transform(parse_json),
{"priorityList": [{
"formitaeten": validate.all(
[{
"type": str,
"qualities": validate.all(
[{
"quality": str,
"audio": {
"tracks": [{
"uri": validate.url()
}]
}
}],
validate.filter(lambda obj: obj["quality"] == "auto")
)
}],
validate.filter(lambda obj: obj["type"] == "h264_aac_ts_http_m3u8_http")
)
}]},
validate.get("priorityList")
))
for priority in data:
for formitaeten in priority["formitaeten"]:
for quality in formitaeten["qualities"]:
for audio in quality["audio"]["tracks"]:
yield from HLSStream.parse_variant_playlist(self.session, audio["uri"], headers=headers).items()
def test_url_concat(self):
self.assertEqual(url_concat("http://test.se", "one", "two", "three"), "http://test.se/one/two/three")
self.assertEqual(url_concat("http://test.se", "/one", "/two", "/three"), "http://test.se/one/two/three")
self.assertEqual(url_concat("http://test.se/one", "../two", "three"), "http://test.se/two/three")
self.assertEqual(url_concat("http://test.se/one", "../two", "../three"), "http://test.se/three")
def build_hls_url(self):
if not self.server or not self.token:
raise ValueError("server and token must be set")
return url_concat(
self.server, "{0}{1}.m3u8?{2}".format(self.api.channel_id,
self.quality, self.token))
def build_hls_url(self):
if not self.server or not self.token:
raise ValueError("server and token must be set")
return url_concat(self.server, f"{self.api.channel_id}{self.quality}.m3u8?{self.token}")
