def _get_streams(self): res = http.get(self.url, schema=_schema) if not res: return owner = res["vars"]["owner"] token = res["vars"].get("token", "null") swf_url = res["swf"] # Check if the stream is online res = http.get(CHANNEL_DETAILS_URI.format(owner, token)) channel_details = http.json(res, schema=_channel_details_schema) if not channel_details["channel"]["live"]: return stream_ip = http.get(REDIRECT_SERVICE_URI.format(owner)).text streams = {} streams["live"] = RTMPStream( self.session, { "rtmp": RTMP_URL.format(stream_ip, channel_details["channel"]["slug"]), "pageUrl": self.url, "swfUrl": urljoin(self.url, swf_url), "live": True, }, ) return streams
def _get_vod_streams(self): url = 'http://ida.omroep.nl/odi/?prid={}&puboptions=adaptive,h264_bb,h264_std,h264_sb&adaptive=no&part=1&token={}'.format(self.npo_id, self.get_token()) data = http.get(url, headers=HTTP_HEADERS).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_rtmp_streams(self, swfurl): if not RTMPStream.is_usable(self.session): raise NoStreamsError(self.url) self.logger.debug("Fetching RTMP stream info") res = http.get(swfurl) swf = swfdecompress(res.content) match = re.search("customURL[^h]+(https://.*?)\\\\", swf) if not match: raise NoStreamsError(self.url) res = http.get(match.group(1)) rtmp, playpath = rtmpparse(res.text) params = { "rtmp": rtmp, "pageUrl": self.url, "playpath": playpath, "live": True } match = re.search("file[^h]+(https?://.*?.swf)", swf) if match: params["swfUrl"] = match.group(1) return RTMPStream(self.session, params)
def _get_streams(self): channelname = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower() self.logger.debug("Fetching stream info") headers = { "Referer": self.url } res = http.get(self.PlayerURL.format(channelname), headers=headers) match = re.search("'FlashVars', '(id=\d+)&s=(.+?)&", res.text) if not match: raise NoStreamsError(self.url) channelname = "{0}?{1}".format(match.group(2), match.group(1)) res = http.get(self.BalancerURL, headers=headers) match = re.search("redirect=(.+)", res.text) if not match: raise PluginError("Error retrieving RTMP address from loadbalancer") rtmp = match.group(1) streams = {} streams["live"] = RTMPStream(self.session, { "rtmp": "rtmp://{0}/live/{1}".format(rtmp, channelname), "pageUrl": self.url, "swfVfy": self.SWFURL, "conn": "S:OK", "live": True }) return streams
def _get_streams(self): channelname = urlparse( self.url).path.rstrip("/").rpartition("/")[-1].lower() self.logger.debug("Fetching stream info") headers = {"Referer": self.url} res = http.get(self.PlayerURL.format(channelname), headers=headers) match = re.search("'FlashVars', '(id=\d+)&s=(.+?)&", res.text) if not match: raise NoStreamsError(self.url) channelname = "{0}?{1}".format(match.group(2), match.group(1)) res = http.get(self.BalancerURL, headers=headers) match = re.search("redirect=(.+)", res.text) if not match: raise PluginError( "Error retrieving RTMP address from loadbalancer") rtmp = match.group(1) streams = {} streams["live"] = RTMPStream( self.session, { "rtmp": "rtmp://{0}/live/{1}".format(rtmp, channelname), "pageUrl": self.url, "swfVfy": self.SWFURL, "conn": "S:OK", "live": True }) return streams
def _get_streams(self): res = http.get(self.url) channel_id = self._find_channel_id(res.text) if not channel_id: return stream_id = self._get_stream_id(channel_id) if not stream_id: return res = http.get(STREAM_API_URL.format(stream_id), params=dict(format="all")) items = http.json(res, schema=_stream_schema) streams = {} for stream in items: parser = STREAM_TYPES[stream["format"]] try: streams.update(parser(self.session, stream["url"])) except IOError as err: if not re.search(r"(404|400) Client Error", str(err)): self.logger.error("Failed to extract {0} streams: {1}", stream["format"].upper(), err) return streams
def _get_streams(self): res = http.get(self.url) channel_id = self._find_channel_id(res.text) if not channel_id: return stream_id = self._get_stream_id(channel_id) if not stream_id: return res = http.get(STREAM_API_URL.format(stream_id), params=dict(format="all")) json = http.json(res) data = verifyjson(json, "data") items = verifyjson(data, "items") streams = {} for stream in filter(valid_stream, items): parser = STREAM_TYPES[stream["format"]] try: streams.update(parser(self.session, stream["url"])) except IOError as err: if not re.search(r"(404|400) Client Error", str(err)): self.logger.error("Failed to extract {0} streams: {1}", stream["format"].upper(), err) return streams
def _get_streams(self): info = http.get(self.url, schema=_schema) if not info: return headers = {"Referer": self.url} res = http.get(info["token_url"], headers=headers) token = http.json(res, schema=_token_schema) parsed = urlparse(info["rtmp_url"]) if parsed.query: app = "{0}?{1}".format(parsed.path[1:], parsed.query) else: app = parsed.path[1:] params = { "rtmp": info["rtmp_url"], "app": app, "pageUrl": self.url, "swfVfy": info["swf_url"], "playpath": info["rtmp_playpath"], "token": token, "live": True } stream = RTMPStream(self.session, params) return dict(live=stream)
def _get_streams(self): self.logger.debug("Fetching stream info") res = http.get(self.url) match = re.search("\"User_channelid\".+?value=\"(.+?)\"", res.text) if not match: raise NoStreamsError(self.url) headers = { "Referer": self.url } res = http.get(self.PlayerURL.format(match.group(1)), headers=headers) match = re.search("stream:\s+'(rtmp://.+?)'", res.text) if not match: raise NoStreamsError(self.url) rtmp = match.group(1) streams = {} streams["live"] = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "swfVfy": self.SWFURL, "live": True }) return streams
def _choose_server(self, json): res = http.get(self.GEOIPURL) loc = http.json(res) loc = [loc["latitude"], loc["longitude"]] sel_dist = float("inf") i = 0 primary = -1 secondary = -1 for server in json["server"]: res = http.get(self.GEOURL+server["server"]["name"]+"&sensor=false") cord = http.json(res) cord = [cord["results"][0]["geometry"]["location"]["lat"], cord["results"][0]["geometry"]["location"]["lng"]] cur_dist = self._distance(loc, cord) if cur_dist < sel_dist: sel_dist = cur_dist if server["server"]["used"] < 90: # nearest server with load < 90% primary = i else: # nearest server with load > 90% secondary = i i += 1 if primary == -1: # if all servers have load over 90% use nearest one return secondary return primary
def _get_streams(self): self.logger.debug("Fetching stream info") res = http.get(self.url) match = re.search("\"User_channelid\".+?value=\"(.+?)\"", res.text) if not match: raise NoStreamsError(self.url) headers = {"Referer": self.url} res = http.get(self.PlayerURL.format(match.group(1)), headers=headers) match = re.search("stream:\s+'(rtmp://.+?)'", res.text) if not match: raise NoStreamsError(self.url) rtmp = match.group(1) streams = {} streams["live"] = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "swfVfy": self.SWFURL, "live": True }) return streams
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": swf_url = SWF_URL for playlist in player.get("playlist", []): bitrates = playlist.get("bitrates") provider = playlist.get("connectionProvider") rtmp = None if bitrates: rtmp = playlist.get("netConnectionUrl") elif provider and provider in player["plugins"]: provider = player["plugins"][provider] swf_name = provider["url"] swf_url = SWF_BASE + swf_name rtmp = provider["netConnectionUrl"] bitrates = player["clip"]["bitrates"] else: continue for bitrate in bitrates: quality = self._get_quality(bitrate["label"]) url = bitrate["url"] stream = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "playpath": url, "swfVfy": swf_url, "live": True }) yield quality, stream else: base_url = player["clip"]["baseUrl"] or VOD_BASE_URL for bitrate in player["clip"]["bitrates"]: url = base_url + "/" + bitrate["url"] quality = self._get_quality(bitrate["label"]) if urlparse(url).path.endswith("m3u8"): stream = HLSStream(self.session, url) else: stream = HTTPStream(self.session, url) yield quality, stream
def _get_streams(self): res = http.get(self.url, schema=_schema) if not res: return owner = res["vars"]["owner"] token = res["vars"].get("token", "null") swf_url = res["swf"] # Check if the stream is online res = http.get(CHANNEL_DETAILS_URI.format(owner, token)) channel_details = http.json(res, schema=_channel_details_schema) if not channel_details["channel"]["live"]: return stream_ip = http.get(REDIRECT_SERVICE_URI.format(owner)).text streams = {} streams["live"] = RTMPStream( self.session, { "rtmp": RTMP_URL.format(stream_ip, channel_details["channel"]["slug"]), "pageUrl": self.url, "swfUrl": urljoin(self.url, swf_url), "live": True }) return streams
def _get_vod_streams(self, channelname): res = http.get(self.url) match = re.search('autoURL%22%3A%22(.*?)%22', res.text) if not match: raise PluginError('Error retrieving manifest url') manifest_url = unquote(match.group(1)).replace('\\', '') try: res = http.get(manifest_url) manifest = http.json(res) except: raise PluginError('Error retrieving manifest') # A fallback host (http://proxy-xx...) is sometimes provided # that we could make us of. streams = {} for params in manifest.get('alternates', []): name = params.get('name') template = params.get('template') if not (name and template): continue name = '{0}p'.format(name) streams[name] = self._create_flv_playlist(template) return streams
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
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_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)
def _get_live_streams(self): meta = self._get_meta() stream = filter(lambda x: x['type'] == 'hls', meta['streams'])[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).content 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): self.logger.debug("Fetching stream info") media_is_live = 0 match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url) if not match: raise NoStreamsError(self.url) stream_name, media_id = match.groups() if stream_name != "video": res = http.get(LIVE_API.format(stream_name)) json = http.json(res) livestream = verifyjson(json, "livestream") media_id = verifyjson(livestream[0], "media_id") media_is_live = int(verifyjson(livestream[0], "media_is_live")) if not media_is_live: raise NoStreamsError(self.url) media_type = "live" if media_is_live else "video" res = http.get(PLAYER_API.format(media_type, media_id)) json = http.json(res) clip = verifyjson(json, "clip") live = verifyjson(clip, "live") bitrates = verifyjson(clip, "bitrates") streams = {} if live: for bitrate in bitrates: connection_provider = clip.get("connectionProvider", "clustering") plugins = verifyjson(json, "plugins") provider_plugin = verifyjson(plugins, connection_provider) swf = verifyjson(provider_plugin, "url") rtmp = verifyjson(provider_plugin, "netConnectionUrl") quality = self._get_quality(verifyjson(bitrate, "label")) url = verifyjson(bitrate, "url") streams[quality] = RTMPStream( self.session, { "rtmp": rtmp, "pageUrl": self.url, "playpath": url, "swfVfy": SWF_BASE + swf, "live": True }) else: for bitrate in bitrates: base_url = verifyjson(clip, "baseUrl") url = verifyjson(bitrate, "url") quality = self._get_quality(verifyjson(bitrate, "label")) streams[quality] = HTTPStream(self.session, base_url + "/" + url) return streams
def _get_streams(self): # If email option given, try to login if self.options.get("email"): res = http.get(self.LOGINPAGEURL) match = re.search('<meta content="([^"]+)" name="csrf-token"', res.text) if not match: raise PluginError("Missing CSRF Token: " + self.LOGINPAGEURL) csrf_token = match.group(1) email = self.options.get("email") password = self.options.get("password") res = http.post( self.LOGINPOSTURL, data={ 'authenticity_token': csrf_token, 'channel_id': '', 'commit': 'Login', 'plan_id': '', 'session[email]': email, 'session[password]': password, 'utf8': "\xE2\x9C\x93", # Check Mark Character }) self.logger.debug("Login account info: {0}", res.text) result = http.json(res) if result.get('email', 'no-mail') != email: raise PluginError("Invalid account") res = http.get(self.url) streams = {} if RTMPStream.is_usable(self.session): try: rtmpstreams = self._get_rtmp_streams(res.text) streams.update(rtmpstreams) except PluginError as err: self.logger.error("Error when fetching RTMP stream info: {0}", str(err)) else: self.logger.warning( "rtmpdump is not usable, only HLS streams will be available") try: hlsstreams = self._get_hls_streams(res.text) streams.update(hlsstreams) except PluginError as err: self.logger.error("Error when fetching HLS stream info: {0}", str(err)) return streams
def _get_streams(self): self.logger.debug("Fetching stream info") media_is_live = 0 match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url) if not match: raise NoStreamsError(self.url) stream_name, media_id = match.groups() if stream_name != "video": res = http.get(LIVE_API.format(stream_name)) json = http.json(res) livestream = verifyjson(json, "livestream") media_id = verifyjson(livestream[0], "media_id") media_is_live = int(verifyjson(livestream[0], "media_is_live")) if not media_is_live: raise NoStreamsError(self.url) media_type = "live" if media_is_live else "video" res = http.get(PLAYER_API.format(media_type, media_id)) json = http.json(res) clip = verifyjson(json, "clip") live = verifyjson(clip, "live") bitrates = verifyjson(clip, "bitrates") streams = {} if live: for bitrate in bitrates: connection_provider = clip.get("connectionProvider", "clustering") plugins = verifyjson(json, "plugins") provider_plugin = verifyjson(plugins, connection_provider) swf = verifyjson(provider_plugin, "url") rtmp = verifyjson(provider_plugin, "netConnectionUrl") quality = self._get_quality(verifyjson(bitrate, "label")) url = verifyjson(bitrate, "url") streams[quality] = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "playpath": url, "swfVfy": SWF_BASE + swf, "live": True }) else: for bitrate in bitrates: base_url = verifyjson(clip, "baseUrl") url = verifyjson(bitrate, "url") quality = self._get_quality(verifyjson(bitrate, "label")) streams[quality] = HTTPStream(self.session, base_url + "/" + url) return streams
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_streams(self): url_match = _url_re.match(self.url) if url_match: # find the list of channels from the html in the page res = http.get(self.url) channel_map = dict(_channel_map_re.findall(res.text)) channel_id = channel_map.get(url_match.group(1)) # get the stream urls res = http.get(STREAM_INFO_URL.format(id=channel_id)) stream_data = http.json(res, schema=_channel_schema) return HLSStream.parse_variant_playlist(self.session, stream_data["stream"])
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_streams(self): url_match = _url_re.match(self.url) if url_match: # find the list of channels from the html in the page res = http.get(self.url) channel_map = dict(_channel_map_re.findall(res.text)) channel_id = channel_map.get(url_match.group(1)) # get the stream urls res = http.get(STREAM_INFO_URL.format(id=channel_id)) stream_data = http.json(res, schema=_channel_schema) return HLSStream.parse_variant_playlist(self.session, stream_data['stream'])
def _get_streams(self): self.logger.debug("Fetching stream info") media_is_live = 0 match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url) if not match: return stream_name, media_id = match.groups() if stream_name != "video": res = http.get(LIVE_API.format(stream_name)) json = http.json(res) livestream = verifyjson(json, "livestream") media_id = verifyjson(livestream[0], "media_id") media_is_live = int(verifyjson(livestream[0], "media_is_live")) if not media_is_live: return media_type = "live" if media_is_live else "video" res = http.get(PLAYER_API.format(media_type, media_id)) json = http.json(res) clip = verifyjson(json, "clip") live = verifyjson(clip, "live") streams = {} if live: playlists = verifyjson(json, "playlist") or [] for playlist in filter(valid_playlist, playlists): bitrates = playlist.get("bitrates") rtmp = playlist.get("netConnectionUrl") for bitrate in bitrates: quality = self._get_quality(verifyjson(bitrate, "label")) url = verifyjson(bitrate, "url") streams[quality] = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "playpath": url, "swfVfy": SWF_URL, "live": True }) else: bitrates = verifyjson(clip, "bitrates") for bitrate in bitrates: base_url = verifyjson(clip, "baseUrl") url = verifyjson(bitrate, "url") quality = self._get_quality(verifyjson(bitrate, "label")) streams[quality] = HTTPStream(self.session, base_url + "/" + url) return streams
def _get_streams(self): # If email option given, try to login if self.options.get("email"): res = http.get(self.LOGINPAGEURL) match = re.search('<meta content="([^"]+)" name="csrf-token"', res.text) if not match: raise PluginError("Missing CSRF Token: " + self.LOGINPAGEURL) csrf_token = match.group(1) email = self.options.get("email") password = self.options.get("password") res = http.post( self.LOGINPOSTURL, data={ "authenticity_token": csrf_token, "channel_id": "", "commit": "Login", "plan_id": "", "session[email]": email, "session[password]": password, "utf8": "\xE2\x9C\x93", # Check Mark Character }, ) self.logger.debug("Login account info: {0}", res.text) result = http.json(res) if result.get("email", "no-mail") != email: raise PluginError("Invalid account") res = http.get(self.url) streams = {} if RTMPStream.is_usable(self.session): try: rtmpstreams = self._get_rtmp_streams(res.text) streams.update(rtmpstreams) except PluginError as err: self.logger.error("Error when fetching RTMP stream info: {0}", str(err)) else: self.logger.warning("rtmpdump is not usable, only HLS streams will be available") try: hlsstreams = self._get_hls_streams(res.text) streams.update(hlsstreams) except PluginError as err: self.logger.error("Error when fetching HLS stream info: {0}", str(err)) return streams
def _get_streams(self): res = http.get(self.url, schema=_schema) if res["live"]: return self._get_live_streams(res["lang"]) else: return self._get_video_streams(res["videso"])
def _get_streams(self): res = http.get(self.url) # temporary fix until the jwplayer-parser works for this site again # refer to: https://github.com/chrippa/livestreamer/issues/588 # # not working: # playlist = jwplayer.parse_playlist(res) playlist = re.compile(r"playlist: (\[{.*?}\]),", re.DOTALL + re.IGNORECASE).search( res.content).group(1).strip() playlist = playlist.replace('sources:', '"sources":') playlist = playlist.replace('file:', '"file":') playlist = json.loads(playlist) if not playlist: return for item in playlist: for source in item["sources"]: filename = source["file"] if filename.endswith(".smil"): # TODO: Replace with "yield from" when dropping Python 2. for stream in self._get_smil_streams(filename): yield stream elif filename.startswith("/"): name = source.get("label", "vod") url = BASE_VOD_URL + filename yield name, HTTPStream(self.session, url) break
def _api_call(self, entrypoint, params, schema=None): """Makes a call against the api. :param entrypoint: API method to call. :param params: parameters to include in the request data. :param schema: schema to use to validate the data """ url = API_URL.format(entrypoint) # Default params params = dict(params) params.update({ "version": API_VERSION, "locale": API_LOCALE, }) if self.session_id: params["session_id"] = self.session_id # The certificate used by Crunchyroll cannot be verified in some environments. res = http.get(url, params=params, headers=API_HEADERS, verify=False) json_res = http.json(res, schema=_api_schema) if json_res["error"]: err_msg = json_res.get("message", "Unknown error") err_code = json_res.get("code", "unknown_error") raise CrunchyrollAPIError(err_msg, err_code) data = json_res.get("data") if schema: data = schema.validate(data, name="API response") return data
def _get_player_params(self, retries=3): res = http.get(self.url) match = re.search("<param name=\"playerKey\" value=\"(.+)\" />", res.text) if not match: # The HTML returned sometimes doesn't contain the parameters if not retries: raise PluginError("Missing key 'playerKey' in player params") else: return self._get_player_params(retries - 1) key = match.group(1) match = re.search("<param.+name=\"@videoPlayer\" value=\"(.+)\" />", res.text) if not match: raise PluginError("Missing key 'videoPlayer' in player params") video_player = match.group(1) match = re.search("<param name=\"playerID\" value=\"(\d+)\" />", res.text) if not match: raise PluginError("Missing key 'playerID' in player params") player_id = match.group(1) match = re.search("<!-- live on -->", res.text) if not match: match = re.search("<div id=\"channel_live\">", res.text) is_live = not not match return key, video_player, player_id, is_live
def _get_streams(self): res = http.get(self.url) match = _info_re.search(res.text) if not match: return info = parse_json(match.group(1), schema=_schema) stream_name = info["mode"] mp4_url = info.get("mp4_url") ios_url = info.get("ios_url") swf_url = info.get("swf_url") if mp4_url: stream = HTTPStream(self.session, mp4_url) yield stream_name, stream if ios_url: if urlparse(ios_url).path.endswith(".m3u8"): streams = HLSStream.parse_variant_playlist( self.session, ios_url) # TODO: Replace with "yield from" when dropping Python 2. for stream in streams.items(): yield stream if swf_url: stream = self._get_rtmp_stream(swf_url) if stream: yield stream_name, stream
def _create_streams(self, type_, video_id): url = self._generate_security_url(type_, video_id) res = http.get(url) return HDSStream.parse_manifest(self.session, res.text, cookies=res.cookies)
def _get_streams(self): res = http.get(self.StreamURL, data={"from": "ongamenet"}) match = re.search("var stream = \"(.+?)\";", res.text) if not match: raise NoStreamsError(self.url) stream = match.group(1) match = re.search("var server = \"(.+?)\";", res.text) if not match: raise NoStreamsError(self.url) server = match.group(1) streams = {} streams["live"] = RTMPStream(self.session, { "rtmp": server, "playpath": stream, "swfUrl": self.SWFURL, "pageUrl": self.PageURL, "live": True, }) return streams
def _get_streams(self): res = http.get(self.url, headers=HEADERS) match = _embed_re.search(res.text) if match: url = match.group(0) return self.session.streams(url)
def _get_streams(self): res = http.get(self.StreamURL, data={"from": "ongamenet"}) match = re.search("var stream = \"(.+?)\";", res.text) if not match: raise NoStreamsError(self.url) stream = match.group(1) match = re.search("var server = \"(.+?)\";", res.text) if not match: raise NoStreamsError(self.url) server = match.group(1) streams = {} streams["live"] = RTMPStream( self.session, { "rtmp": server, "playpath": stream, "swfUrl": self.SWFURL, "pageUrl": self.PageURL, "live": True, }) return streams
def _get_streams(self): match = _url_re.match(self.url) parsed = urlparse(self.url) if parsed.fragment: channel_id = parsed.fragment 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_player_params(self, retries=5): match = _url_re.match(self.url) domain = match.group('domain') try: res = http.get(CHANNEL_INFO_URL % str(domain)) except PluginError as err: # The server sometimes gives us 404 for no reason if "404" in str(err) and retries: sleep(1) return self._get_player_params(retries - 1) else: raise channel_info = http.json(res) channel_info = channel_info['data'] key = channel_info['player_key'] is_live = channel_info['is_live'] stream_video = channel_info['stream_video'] if stream_video: video_player = "ref:" + stream_video['reference_id'] else: is_live = False player_id = channel_info['player_id'] return key, video_player, player_id, is_live
def _get_stream_info(self, assign_url, cdn, quality, broad_key, type): headers = { "Referer": self.url, } params = { "rtmp": { "return_type": cdn, "use_cors": "true", "cors_origin_url": "play.afreecatv.com", "broad_key": "{broad_key}-flash-{quality}-{type}".format( broad_key=broad_key, quality=quality, type=type), "time": 1234.56 }, "hls": { "return_type": cdn, "use_cors": "true", "cors_origin_url": "play.afreecatv.com", "broad_key": "{broad_key}-flash-{quality}-{type}".format( broad_key=broad_key, quality=quality, type=type), "time": 1234.56 } } res = http.get(assign_url, params=params[type], headers=headers) return http.json(res, schema=_stream_schema)
def _get_stream_info(self): res = http.get(self.url) match = re.search("window.config = ({.+})", res.text) if match: config = match.group(1) return parse_json(config, "config JSON", schema=_stream_config_schema)
def _get_player_params(self, retries=5): match = _url_re.match(self.url); domain = match.group('domain'); try: res = http.get(CHANNEL_INFO_URL % str(domain)) except PluginError as err: # The server sometimes gives us 404 for no reason if "404" in str(err) and retries: sleep(1) return self._get_player_params(retries - 1) else: raise channel_info = http.json(res) channel_info = channel_info['data'] key = channel_info['player_key']; is_live = channel_info['is_live']; stream_video = channel_info['stream_video'] if stream_video: video_player = "ref:" + stream_video['reference_id'] else: is_live = False player_id = channel_info['player_id'] return key, video_player, player_id, is_live
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_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_streams(self): res = http.get(self.url) match = _info_re.search(res.text) if not match: return info = parse_json(match.group(1), schema=_schema) stream_name = info["mode"] mp4_url = info.get("mp4_url") ios_url = info.get("ios_url") swf_url = info.get("swf_url") if mp4_url: stream = HTTPStream(self.session, mp4_url) yield stream_name, stream if ios_url: if urlparse(ios_url).path.endswith(".m3u8"): streams = HLSStream.parse_variant_playlist(self.session, ios_url) # TODO: Replace with "yield from" when dropping Python 2. for stream in streams.items(): yield stream if swf_url: stream = self._get_rtmp_stream(swf_url) if stream: yield stream_name, stream
def _get_streams(self): self.logger.debug("Fetching stream info") res = http.get(self.url) match = re.search("var info = (.*);", res.text) if not match: raise NoStreamsError(self.url) json = parse_json(match.group(1)) if not isinstance(json, dict): return ios_url = json.get("ios_url") swf_url = json.get("swf_url") streams = {} if ios_url: hls = HLSStream.parse_variant_playlist(self.session, ios_url) streams.update(hls) if swf_url: try: streams["live"] = self._get_rtmp_streams(swf_url) except NoStreamsError: pass return streams
def _parse_smil(self, url, swf_url): res = http.get(url) smil = http.xml(res, "SMIL config", schema=_smil_schema) for src, bitrate in smil["videos"]: url = urljoin(smil["http_base"], src) yield bitrate, AkamaiHDStream(self.session, url, swf=swf_url)
def _get_streams(self): res = http.get(self.url) # temporary fix until the jwplayer-parser works for this site again # refer to: https://github.com/chrippa/livestreamer/issues/588 # # not working: # playlist = jwplayer.parse_playlist(res) playlist = re.compile(r"playlist: (\[{.*?}\]),", re.DOTALL + re.IGNORECASE).search(res.content).group(1).strip() playlist = playlist.replace('sources:', '"sources":') playlist = playlist.replace('file:', '"file":') playlist = json.loads(playlist) if not playlist: return for item in playlist: for source in item["sources"]: filename = source["file"] if filename.endswith(".smil"): # TODO: Replace with "yield from" when dropping Python 2. for stream in self._get_smil_streams(filename): yield stream elif filename.startswith("/"): name = source.get("label", "vod") url = BASE_VOD_URL + filename yield name, HTTPStream(self.session, url) break
def _find_broadcast(self, username): res = http.get(CHANNEL_URL, headers=HEADERS, params=dict(szBjId=username)) match = re.search(r"<thumb>.+\/(\d+)\.gif</thumb>", res.text) if match: return match.group(1)
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): match = _url_re.match(self.url) video_id = match.group("video_id") res = http.get(API_URL, params=dict(ak="web", id=video_id)) fmts = http.xml(res, schema=_schema) streams = {} for fmt in fmts: if fmt["type"] in STREAMING_TYPES: name, parser = STREAMING_TYPES[fmt["type"]] try: streams.update(parser(self.session, fmt["url"])) except IOError as err: self.logger.error("Failed to extract {0} streams: {1}", name, err) elif fmt["type"] == "h264_aac_mp4_rtmp_zdfmeta_http": name = fmt["quality"] try: streams[name] = self._create_rtmp_stream(fmt["url"]) except IOError as err: self.logger.error("Failed to extract RTMP stream '{0}': {1}", name, err) return streams
def _get_streams(self): json_url = http.get(self.url, schema=_schema) if not json_url: return res = http.get(json_url) video = http.json(res, schema=_video_schema) if not video["videoJsonPlayer"]["VSR"]: return is_live = video["videoJsonPlayer"]["VTY"] == "LIVE" vsr = video["videoJsonPlayer"]["VSR"].values() streams = (self._create_stream(stream, is_live) for stream in vsr) return chain.from_iterable(streams)
def _get_vod_stream(self, movie_id): res = http.get(VODINFO_URL.format(movie_id), headers=AJAX_HEADERS) json = http.json(res) json = json and json.get("data") json = json and json.get("streams") if not json: raise NoStreamsError(self.url) streams = {} for quality in ("low", "high"): stream = json.get(quality) if not stream: continue rtmp = stream.get("url") app = self._get_rtmp_app(rtmp) if not app: continue playpath = stream.get("name") if ".mp4" in playpath: playpath = "mp4:" + playpath streams[quality] = RTMPStream(self.session, { "rtmp": rtmp, "pageUrl": self.url, "swfUrl": SWF_URL, "playpath": playpath, "app": app, }) return streams