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