def open(self):
try:
self.con = socket.create_connection((self.ip, self.port))
self.con.send(struct.pack("<LL", self.uid, self.sid))
except IOError:
raise PluginError("could not connect to Bigo Stream")
return self
def _get_streams(self):
http.headers.update({'User-Agent': useragents.FIREFOX})
log.debug('Version 2018-07-01')
log.info('This is a custom plugin. '
'For support visit https://github.com/back-to/plugins')
res = http.get(self.url)
m = self._token_re.search(res.text)
if not m:
raise PluginError('No token found.')
data = {
'_method': 'PATCH',
'_token': m.group('data')
}
http.post(self.verify_url, data=data)
res = http.get(self.url)
m = self._hls_re.search(res.text)
if not m:
log.debug('No video url found.')
return
hls_url = m.group('url')
log.debug('URL={0}'.format(hls_url))
streams = HLSStream.parse_variant_playlist(self.session, hls_url)
if not streams:
return {'live': HLSStream(self.session, hls_url)}
else:
return streams
def _get_streams(self):
if not self.login(self.get_option("email"),
self.get_option("password")):
raise PluginError("Login failed")
try:
start_point = int(
float(
dict(parse_qsl(urlparse(self.url).query)).get(
"startPoint", 0.0)))
if start_point > 0:
log.info("Stream will start at {0}".format(
seconds_to_hhmmss(start_point)))
except ValueError:
start_point = 0
content_id = self._get_video_id()
if content_id:
log.debug("Found content ID: {0}".format(content_id))
info = self._get_media_info(content_id)
if info.get("hlsUrl"):
for s in HLSStream.parse_variant_playlist(
self.session, info["hlsUrl"],
start_offset=start_point).items():
yield s
else:
log.error("Could not find the HLS URL")
def get_token(self):
"""
Get the token for USTVNow
:return: a valid token
"""
if not self._token:
log.debug("Getting new session token")
res = self.session.http.get(self._token_url,
params={
"tenant_code": self.TENANT_CODE,
"box_id": self.box_id,
"product": self.TENANT_CODE,
"device_id": 5,
"display_lang_code": "ENG",
"device_sub_type": "",
"timezone": "UTC"
})
data = res.json()
if data['status']:
self._token = data['response']['sessionId']
log.debug("New token: {}".format(self._token))
else:
log.error(
"Token acquisition failed: {details} ({detail})".format(
**data['error']))
raise PluginError("could not obtain token")
return self._token
def _login(self, email, password):
log.debug('_login ... Attempting login as {0}'.format(email))
login_url = self.API_LOGIN.format(self.base_url)
params = {'login': email, 'password': password, 'remember': 'true'}
try:
res = self.session.http.post(login_url,
headers=self.headers,
data=params)
except Exception as e:
if '400 Client Error' in str(e):
raise PluginError(
'Failed to login, check your username/password')
raise e
data = self.session.http.json(res)
self._authed = data['success']
log.debug('New Session Data')
self.save_cookies(default_expires=self.TIME_SESSION)
self._session_attributes.set('power_guide_hash',
data['session']['power_guide_hash'],
expires=self.TIME_SESSION)
self._session_attributes.set('session_control',
True,
expires=self.TIME_CONTROL)
def _get_streams(self):
m = self._live_url_re.search(self.page.text)
playlist_url = m and update_scheme(self.url, m.group(1))
player_url = self.url
token = self._get_token()
if playlist_url:
log.debug("Found playlist URL in the page")
else:
live_channel = None
for div in itertags(self.page.text, "div"):
if div.attributes.get("id") == "botonLive":
live_channel = div.attributes.get("data-canal")
if live_channel:
log.debug("Live channel: {0}".format(live_channel))
player_url = self._channel_urls[live_channel] + quote(token)
page = self.session.http.get(player_url,
raise_for_status=False)
if "block access from your country." in page.text:
raise PluginError("Content is geo-locked")
m = self._playlist_re.search(page.text)
playlist_url = m and update_scheme(self.url, m.group(1))
else:
log.error("Could not find the live channel")
if playlist_url:
stream_url = "{0}?{1}".format(playlist_url,
urlencode({"iut": token}))
return HLSStream.parse_variant_playlist(
self.session, stream_url, headers={"referer": player_url})
def __init__(self, session, sid, uid, ip, port):
super(BigoStream, self).__init__(session)
try:
self.sid = int(sid)
self.uid = int(uid)
except ValueError:
raise PluginError(
"invalid sid or uid parameter for Bigo Stream: {0}/{1}".format(
self.sid, self.uid))
self.ip = ip
try:
self.port = int(port)
except ValueError:
raise PluginError(
"invalid port number for Bigo Stream: {0}:{1}".format(
self.ip, self.port))
self.con = None
def policy_key(self, video_id):
# Get the embedded player page
res = http.get(self.player_url(video_id))
policy_key_m = self.policy_key_re.search(res.text)
policy_key = policy_key_m and policy_key_m.group("key")
if not policy_key:
raise PluginError("Could not find Brightcove policy key")
return policy_key
def _get_streams(self):
res = self.session.http.get(self.url)
# Search for the iframe in the page
iframe_m = self.iframe_re.search(res.text)
ustream_url = iframe_m and iframe_m.group(1)
if ustream_url and "ott.streann.com" in ustream_url:
try:
return self.session.streams(ustream_url)
except NoPluginError:
raise PluginError(
"Could not play embedded stream: {0}".format(ustream_url))
def parse_manifest(cls, session, url, **args):
"""
Attempt to parse a DASH manifest file and return its streams
:param session: Streamlink session instance
:param url: URL of the manifest file
:return: a dict of name -> DASHStream instances
"""
ret = {}
res = session.http.get(url, **args)
url = res.url
urlp = list(urlparse(url))
urlp[2], _ = urlp[2].rsplit("/", 1)
mpd = MPD(session.http.xml(res, ignore_ns=True),
base_url=urlunparse(urlp),
url=url)
video, audio = [], []
# Search for suitable video and audio representations
for aset in mpd.periods[0].adaptationSets:
if aset.contentProtection:
raise PluginError("{} is protected by DRM".format(url))
for rep in aset.representations:
if rep.mimeType.startswith("video"):
video.append(rep)
elif rep.mimeType.startswith("audio"):
audio.append(rep)
if not video:
video = [None]
if not audio:
audio = [None]
for vid, aud in itertools.product(video, audio):
stream = DASHStream(session, mpd, vid, aud, **args)
stream_name = []
if vid:
stream_name.append("{:0.0f}{}".format(
vid.height or vid.bandwidth, "p" if vid.height else "k"))
if audio and len(audio) > 1:
stream_name.append("a{:0.0f}k".format(aud.bandwidth))
ret['+'.join(stream_name)] = stream
return ret
def login(self, username, password, depth=3):
if depth == 0:
log.error("Failed to login to YuppTV")
raise PluginError("cannot login")
res = self.session.http.post(
self._login_url,
data=dict(user=username, password=password, isMobile=0),
headers={"Referer": self._signin_url}
)
data = self.session.http.json(res)
resp = data['Response']
if resp["tempBoxid"]:
# log out on other device
log.info("Logging out on other device: {0}".format(resp["tempBoxid"]))
_ = self.session.http.get(self._box_logout, params=dict(boxId=resp["tempBoxid"]))
return self.login(username, password, depth - 1)
return resp['errorCode'], resp['statusmsg']
def _login(self, username, password):
res = http.get(self.login_url_get)
m = self._post_key_re.search(res.text)
if not m:
raise PluginError("Missing post_key, no login posible.")
post_key = m.group("data")
data = {
"lang": "en",
"source": "sketch",
"post_key": post_key,
"pixiv_id": username,
"password": password,
}
res = http.post(self.login_url_post, data=data)
res = http.json(res)
if res["body"].get("success"):
return True
else:
return False
def _get_streams(self):
m = self._live_url_re.search(self.page.text)
playlist_url = m and update_scheme(self.url, m.group(1))
player_url = self.url
live_channel = None
p = urlparse(player_url)
channelnumber = 0
if p.netloc.endswith("tvc.com.ec"):
live_channel = "Canal5"
elif p.netloc.endswith("rts.com.ec"):
live_channel = "Guayaquil"
elif p.netloc.endswith("atv.pe"):
if p.path.endswith(("ATVMas", "ATVMas/")):
live_channel = "ATVMas"
channelnumber = 1
else:
live_channel = "ATV"
token = self._get_token(channelnumber)
log.debug("token {0}".format(token))
if playlist_url:
log.debug("Found playlist URL in the page")
else:
if live_channel:
log.debug("Live channel: {0}".format(live_channel))
player_url = self._channel_urls[live_channel] + quote(token)
page = self.session.http.get(player_url,
raise_for_status=False)
if "block access from your country." in page.text:
raise PluginError("Content is geo-locked")
m = self._playlist_re.search(page.text)
playlist_url = m and update_scheme(self.url, m.group(1))
else:
log.error("Could not find the live channel")
if playlist_url:
stream_url = "{0}?{1}".format(playlist_url,
urlencode({"iut": token}))
return HLSStream.parse_variant_playlist(
self.session, stream_url, headers={"referer": player_url})
def _get_streams(self):
email = self.get_option("email")
password = self.get_option("password")
if not self._authed and (not email and not password):
self.logger.error(
"A login for WWE Network is required, use --wwenetwork-email/"
"--wwenetwork-password to set them")
return
if not self._authed:
if not self.login(email, password):
self.logger.error(
"Failed to login, check your username/password")
return
content_id = self._get_content_id()
if content_id:
self.logger.debug("Found content ID: {0}", content_id)
info = self._get_media_info(content_id)
if info["status"]["code"] == 1:
# update the session attributes
self._update_session_attribute("fprt", info.get("fingerprint"))
for attr in info["session_attributes"]:
self._update_session_attribute(attr["name"], attr["value"])
if info.get("session_key"):
self.session_key = info.get("session_key")
for url in info["urls"]:
for s in HLSStream.parse_variant_playlist(
self.session, url,
name_fmt="{pixels}_{bitrate}").items():
yield s
else:
raise PluginError(
"Could not load streams: {message} ({code})".format(
**info["status"]))
def parse_manifest(cls, session, url_or_manifest, **args):
"""
Attempt to parse a DASH manifest file and return its streams
:param session: Streamlink session instance
:param url_or_manifest: URL of the manifest file or an XML manifest string
:return: a dict of name -> DASHStream instances
"""
if url_or_manifest.startswith('<?xml'):
mpd = MPD(parse_xml(url_or_manifest, ignore_ns=True))
else:
res = session.http.get(url_or_manifest, **args)
url = res.url
urlp = list(urlparse(url))
urlp[2], _ = urlp[2].rsplit("/", 1)
mpd = MPD(session.http.xml(res, ignore_ns=True),
base_url=urlunparse(urlp),
url=url)
video, audio = [], []
# Search for suitable video and audio representations
for aset in mpd.periods[0].adaptationSets:
if aset.contentProtection:
raise PluginError("{} is protected by DRM".format(url))
for rep in aset.representations:
if rep.mimeType.startswith("video"):
video.append(rep)
elif rep.mimeType.startswith("audio"):
audio.append(rep)
if not video:
video = [None]
if not audio:
audio = [None]
locale = session.localization
locale_lang = locale.language
lang = None
available_languages = set()
# if the locale is explicitly set, prefer that language over others
for aud in audio:
if aud and aud.lang:
available_languages.add(aud.lang)
try:
if locale.explicit and aud.lang and Language.get(
aud.lang) == locale_lang:
lang = aud.lang
except LookupError:
continue
if not lang:
# filter by the first language that appears
lang = audio[0] and audio[0].lang
log.debug(
"Available languages for DASH audio streams: {0} (using: {1})".
format(", ".join(available_languages) or "NONE", lang or "n/a"))
# if the language is given by the stream, filter out other languages that do not match
if len(available_languages) > 1:
audio = list(
filter(lambda a: a.lang is None or a.lang == lang, audio))
ret = []
for vid, aud in itertools.product(video, audio):
stream = DASHStream(session, mpd, vid, aud, **args)
stream_name = []
if vid:
stream_name.append("{:0.0f}{}".format(
vid.height or vid.bandwidth_rounded,
"p" if vid.height else "k"))
if audio and len(audio) > 1:
stream_name.append("a{:0.0f}k".format(aud.bandwidth))
ret.append(('+'.join(stream_name), stream))
# rename duplicate streams
dict_value_list = defaultdict(list)
for k, v in ret:
dict_value_list[k].append(v)
ret_new = {}
for q in dict_value_list:
items = dict_value_list[q]
for n in range(len(items)):
if n == 0:
ret_new[q] = items[n]
elif n == 1:
ret_new[f'{q}_alt'] = items[n]
else:
ret_new[f'{q}_alt{n}'] = items[n]
return ret_new
