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)