def get(self): data = self.get_urldata() match = re.search("window.pagePlaylist = (.*);", data) if not match: yield ServiceError("Can't find video info") return try: janson = json.loads(match.group(1)) except Exception: yield ServiceError("Can't decode api request: {}".format( match.group(1))) return parse = urlparse(self.url) wanted_id = parse.path.split("/")[-1].split("-")[0] for n in janson: if wanted_id == str(n["id"]): mrssxmlurl = "http://media-utils.mtvnservices.com/services/MediaGenerator/" "mgid:arc:video:mtv.se:{}?acceptMethods=hls".format( n["video_token"]) hls_asset = self.http.request("get", mrssxmlurl) xml = ET.XML(hls_asset.text) if (xml.find("./video") is not None and xml.find("./video").find("item") is not None and xml.find("./video").find("item").find("rendition") is not None and xml.find("./video").find("item").find( "rendition").find("src") is not None): hls_url = xml.find("./video").find("item").find( "rendition").find("src").text stream = hlsparse(self.config, self.http.request("get", hls_url), hls_url, output=self.output) if stream: for key in list(stream.keys()): yield stream[key]
def get(self): data = self.get_urldata() match = re.search(r"RP.vcdData = ({.*});</script>", data) if match: data = json.loads(match.group(1)) for i in list(data["station"]["streams"].keys()): yield HTTP(copy.copy(self.config), data["station"]["streams"][i], i) else: yield ServiceError("Can't find stream info") return
def get(self): urlp = urlparse(self.url) match = re.match(r'/(\w+)/([bcv])/(\d+)', urlp.path) if not match: if re.search("clips.twitch.tv", urlp.netloc): data = self._get_clips() else: data = self._get_channel(urlp) else: if match.group(2) in ["b", "c"]: yield ServiceError("This twitch video type is unsupported") return data = self._get_archive(match.group(3)) try: for i in data: yield i except TwitchUrlException: yield ServiceError("This twitch video type is unsupported") return
def get(self): data = self.get_urldata() if self.exclude(): yield ServiceError("Excluding video") return match = re.search(r'href="(/sida/[\.\/=a-z0-9&;\?]+play(?:audio|episode)=\d+)"', data) if not match: yield ServiceError("Can't find audio info") return path = quote_plus(match.group(1)) dataurl = "http://sverigesradio.se/sida/ajax/getplayerinfo?url=%s&isios=false&playertype=html5" % path data = self.http.request("get", dataurl).text playerinfo = json.loads(data)["playerInfo"] for i in playerinfo["AudioSources"]: url = i["Url"] if not url.startswith('http'): url = 'http:%s' % url yield HTTP(copy.copy(self.options), url, i["Quality"]/1000)
def get(self): data = self.get_urldata() parse = urlparse(self.url) match = re.search(r'^/([a-z]{2})/', parse.path) if not match: yield ServiceError("Cant county code") return res = self.http.get( "http://www.pokemon.com/api/pokemontv/channels?region={0}".format( match.group(1))) janson = res.json() match = re.search('data-video-season="([0-9]+)"', data) season = match.group(1) match = re.search('data-video-episode="([0-9]+)"', data) episode = match.group(1) for i in janson: for n in i["media"]: if season == n["season"] and episode == n["episode"]: stream = n["stream_url"] if self.options.output_auto: directory = os.path.dirname(self.options.output) basename = os.path.basename(self.options.output) title = "pokemon.s{0}e{1}-{2}".format(season, episode, basename) title = filenamify(title) if len(directory): self.options.output = os.path.join(directory, title) else: self.options.output = title if self.exclude(): yield ServiceError("Excluding video") return streams = hlsparse(self.options, self.http.request("get", stream), stream) for n in list(streams.keys()): yield streams[n]
def dashparse(options, res, url): streams = {} if not res: return None if res.status_code >= 400: streams[0] = ServiceError("Can't read DASH playlist. {0}".format(res.status_code)) return streams xml = ET.XML(res.text) if "isoff-on-demand" in xml.attrib["profiles"]: try: baseurl = urljoin(url, xml.find("{urn:mpeg:dash:schema:mpd:2011}BaseURL").text) except AttributeError: streams[0] = ServiceError("Can't parse DASH playlist") return videofiles = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@contentType='video']/{urn:mpeg:dash:schema:mpd:2011}Representation") audiofiles = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@contentType='audio']/{urn:mpeg:dash:schema:mpd:2011}Representation") for i in audiofiles: audiourl = urljoin(baseurl, i.find("{urn:mpeg:dash:schema:mpd:2011}BaseURL").text) audiobitrate = float(i.attrib["bandwidth"]) / 1000 for n in videofiles: bitrate = float(n.attrib["bandwidth"])/1000 + audiobitrate videourl = urljoin(baseurl, n.find("{urn:mpeg:dash:schema:mpd:2011}BaseURL").text) options.other = "mp4" streams[int(bitrate)] = DASH(copy.copy(options), videourl, bitrate, cookies=res.cookies, audio=audiourl) if "isoff-live" in xml.attrib["profiles"]: video = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@contentType='video']") if len(video) == 0: video = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType='video/mp4']") audio = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@contentType='audio']") if len(audio) == 0: audio = xml.findall(".//{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType='audio/mp4']") videofiles = parsesegments(video, url) audiofiles = parsesegments(audio, url) for i in videofiles.keys(): bitrate = (int(i) + int(list(audiofiles.keys())[0])) /1000 options.other = "mp4" streams[int(bitrate)] = DASH(copy.copy(options), url, bitrate, cookies=res.cookies, audio=audiofiles[list(audiofiles.keys())[0]], files=videofiles[i]) return streams
def hlsparse(options, res, url): streams = {} if res.status_code == 403 or res.status_code == 404: streams[0] = ServiceError("Can't read HLS playlist.") return streams files = (parsem3u(res.text))[1] for i in files: bitrate = float(i[1]["BANDWIDTH"])/1000 streams[int(bitrate)] = HLS(copy.copy(options), _get_full_url(i[0], url), bitrate, cookies=res.cookies) return streams
def get(self): match = re.search('data-hls="([^"]+)"', self.get_urldata()) if not match: yield ServiceError("Cant find video info") return streams = hlsparse(self.options, self.http.request("get", match.group(1)), match.group(1)) if streams: for n in list(streams.keys()): yield streams[n]
def get(self): if not self.config.get("username") or not self.config.get("password"): yield ServiceError( "You need username and password to download things from this site." ) return token, message = self._login() if not token: yield ServiceError(message) return res = self.http.get(self.url) match = re.search('data-asset-id="([^"]+)"', res.text) if not match: yield ServiceError("Can't find video id") return tld = self._gettld() url = "https://restapi.cmore.{0}/api/tve_web/asset/{1}/play.json?protocol=VUDASH".format( tld, match.group(1)) res = self.http.get( url, headers={"authorization": "Bearer {0}".format(token)}) janson = res.json() if "error" in janson: yield ServiceError("This video is geoblocked") return basename = self._autoname(match.group(1)) self.output["id"] = match.group(1) if basename is None: yield ServiceError("Cant find vid id for autonaming") return if "drmProtected" in janson["playback"]: if janson["playback"]["drmProtected"]: yield ServiceError("DRM protected. Can't do anything") return if isinstance(janson["playback"]["items"]["item"], list): for i in janson["playback"]["items"]["item"]: if i["mediaFormat"] == "ism": streams = dashparse(self.config, self.http.request("get", i["url"]), i["url"], output=self.output) if streams: for n in list(streams.keys()): yield streams[n] if i["mediaFormat"] == "webvtt": yield subtitle(copy.copy(self.config), "wrst", i["url"]) else: i = janson["playback"]["items"]["item"] if i["mediaFormat"] == "ism": streams = dashparse(self.config, self.http.request("get", i["url"]), i["url"], output=self.output) for n in list(streams.keys()): yield streams[n]
def get(self): if self.exclude(): yield ServiceError("Excluding video") return # First, fint the video ID from the html document match = re.search("<meta name=\"programid\".*?content=\"([^\"]*)\"", self.get_urldata()) if match: video_id = match.group(1) else: yield ServiceError("Can't find video id.") return # Get media element details dataurl = "http://v8.psapi.nrk.no/mediaelement/%s" % (video_id) data = self.http.request("get", dataurl).text data = json.loads(data) manifest_url = data["mediaUrl"] self.options.live = data["isLive"] if manifest_url is None: yield ServiceError(data["messageType"]) return # Check if subtitles are available if data["subtitlesUrlPath"]: yield subtitle(copy.copy(self.options), "tt", data["subtitlesUrlPath"]) hlsurl = manifest_url.replace("/z/", "/i/").replace("manifest.f4m", "master.m3u8") data = self.http.request("get", hlsurl) if data.status_code == 403: yield ServiceError("Can't fetch the video because of geoblocking") return streams = hlsparse(self.options, data, hlsurl) for n in list(streams.keys()): yield streams[n] streams = hdsparse(copy.copy(self.options), self.http.request("get", manifest_url, params={"hdcore": "3.7.0"}), manifest_url) if streams: for n in list(streams.keys()): yield streams[n]
def get(self): urlp = urlparse(self.url) slugs = urlp.path.split('/') courseSlug = slugs[2] lessonSlug = slugs[3] login = self._login() if not login: yield ServiceError("Could not login") return data = self._getData() if data is None: yield ServiceError("Could not fetch data") return course = findCourse(data, courseSlug) if course is None: yield ServiceError("Could not find course") return lesson = findLesson(course, lessonSlug) if lesson is None: yield ServiceError("Could not find lesson") return self.output["id"] = lesson["videoAssetId"] self.output["title"] = lesson["title"] url = "https://playback-api.b17g.net/media/{}?service=tv4&device=browser&protocol=hls%2Cdash&drm=widevine".format(self.output["id"]) videoDataRes = self.http.get(url) if videoDataRes.json()["playbackItem"]["type"] == "hls": streams = hlsparse(self.config, self.http.get(videoDataRes.json()["playbackItem"]["manifestUrl"]), videoDataRes.json()["playbackItem"]["manifestUrl"], output=self.output) for n in list(streams.keys()): yield streams[n]
def _dashparse(config, text, url, output, cookies): streams = {} baseurl = None offset_sec = None duration_sec = None xml = ET.XML(text) if xml.find("./{urn:mpeg:dash:schema:mpd:2011}BaseURL") is not None: baseurl = xml.find("./{urn:mpeg:dash:schema:mpd:2011}BaseURL").text if "availabilityStartTime" in xml.attrib: availabilityStartTime = xml.attrib["availabilityStartTime"] publishTime = xml.attrib["publishTime"] datetime_start = parse_dates(availabilityStartTime) datetime_publish = parse_dates(publishTime) diff_publish = datetime_publish - datetime_start offset_sec = diff_publish.total_seconds() if "mediaPresentationDuration" in xml.attrib: mediaPresentationDuration = xml.attrib["mediaPresentationDuration"] duration_sec = (parse_dates(mediaPresentationDuration) - datetime(1900, 1, 1)).total_seconds() temp = xml.findall( './/{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType="audio/mp4"]' ) audiofiles = adaptionset(temp, url, baseurl, offset_sec, duration_sec) temp = xml.findall( './/{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType="video/mp4"]' ) videofiles = adaptionset(temp, url, baseurl, offset_sec, duration_sec) if not audiofiles or not videofiles: streams[0] = ServiceError( "Found no Audiofiles or Videofiles to download.") return streams for i in videofiles.keys(): bitrate = i + list(audiofiles.keys())[0] streams[bitrate] = DASH(copy.copy(config), url, bitrate, cookies=cookies, audio=audiofiles[list( audiofiles.keys())[0]]["files"], files=videofiles[i]["files"], output=output, segments=videofiles[i]["segments"]) return streams
def get(self): match = re.search("_([A-Z0-9]+)$", self.url) if not match: yield ServiceError("Cant find video id.") return vid = match.group(1) res = self.http.get("http://www.riksdagen.se/api/videostream/get/%s" % vid) data = res.json() try: janson = data["videodata"][0]["streams"]["files"] except TypeError: yield ServiceError("Cant find video.") return for i in janson: if i["mimetype"] == "application/x-mpegurl": data2 = self.http.get(i["url"]).json() streams = hlsparse(self.config, self.http.request("get", data2["url"]), data2["url"], output=self.output) for n in list(streams.keys()): yield streams[n]
def _get_clips(self): match = re.search(r"quality_options: (\[[^\]]+\])", self.get_urldata()) if not match: yield ServiceError("Can't find the video clip") return name = re.search(r'slug: "([^"]+)"', self.get_urldata()).group(1) brodcaster = re.search('broadcaster_login: "******"]+)"', self.get_urldata()).group(1) self.output["title"] = "twitch-{}".format(brodcaster) self.output["episodename"] = name dataj = json.loads(match.group(1)) for i in dataj: yield HTTP(copy.copy(self.config), i["source"], i["quality"], output=self.output)
def get(self): data = self.get_urldata() if self.exclude(): yield ServiceError("Excluding video") return match = re.search('data-config-url="([^"]+)" data-fallback-url', data) if not match: yield ServiceError("Can't find video file for: %s" % self.url) return player_url = match.group(1).replace("&", "&") player_data = self.http.request("get", player_url).text if player_data: jsondata = json.loads(player_data) avail_quality = jsondata["request"]["files"]["progressive"] for i in avail_quality: yield HTTP(copy.copy(self.options), i["url"], i["height"]) else: yield ServiceError("Can't find any streams.") return
def hdsparse(options, res, manifest): streams = {} bootstrap = {} if not res: return None if res.status_code >= 400: streams[0] = ServiceError("Can't read HDS playlist. {0}".format(res.status_code)) return streams data = res.text if is_py2 and isinstance(data, unicode): data = data.encode("utf-8") xml = ET.XML(data) if is_py2_old: bootstrapIter = xml.getiterator("{http://ns.adobe.com/f4m/1.0}bootstrapInfo") mediaIter = xml.getiterator("{http://ns.adobe.com/f4m/1.0}media") else: bootstrapIter = xml.iter("{http://ns.adobe.com/f4m/1.0}bootstrapInfo") mediaIter = xml.iter("{http://ns.adobe.com/f4m/1.0}media") if xml.find("{http://ns.adobe.com/f4m/1.0}drmAdditionalHeader") is not None: streams[0] = ServiceError("HDS DRM protected content.") return streams for i in bootstrapIter: if "id" in i.attrib: bootstrap[i.attrib["id"]] = i.text else: bootstrap["0"] = i.text parse = urlparse(manifest) querystring = parse.query manifest = "%s://%s%s" % (parse.scheme, parse.netloc, parse.path) for i in mediaIter: bootstrapid = bootstrap[i.attrib["bootstrapInfoId"]] streams[int(i.attrib["bitrate"])] = HDS(copy.copy(options), i.attrib["url"], i.attrib["bitrate"], manifest=manifest, bootstrap=bootstrapid, metadata=i.find("{http://ns.adobe.com/f4m/1.0}metadata").text, querystring=querystring, cookies=res.cookies) return streams
def dashparse(options, res, url): streams = {} if not res: return None if res.status_code >= 400: streams[0] = ServiceError("Can't read DASH playlist. {0}".format( res.status_code)) return streams if len(res.text) < 1: streams[0] = ServiceError( "Can't read DASH playlist. {0}, size: {1}".format( res.status_code, len(res.text))) return xml = ET.XML(res.text) temp = xml.findall( './/{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType="audio/mp4"]' ) audiofiles = adaptionset(temp, url) temp = xml.findall( './/{urn:mpeg:dash:schema:mpd:2011}AdaptationSet[@mimeType="video/mp4"]' ) videofiles = adaptionset(temp, url) for i in videofiles.keys(): bitrate = (int(i) + int(list(audiofiles.keys())[0])) options.other = "mp4" options.segments = videofiles[i]["segments"] streams[int(bitrate)] = DASH(copy.copy(options), url, bitrate, cookies=res.cookies, audio=audiofiles[list( audiofiles.keys())[0]]["files"], files=videofiles[i]["files"]) return streams
def get(self): match = re.search(r"var initialMedia\s+= ({[^;]+);", self.get_urldata()) if not match: yield ServiceError("Cant find any media on that page") return janson = json.loads(match.group(1)) vid = janson["content_id"] if not janson["metaData"]: yield ServiceError("Can't find video on that page") return if "playbacks" in janson["metaData"]: for i in janson["metaData"]["playbacks"]: if "CLOUD" in i["name"]: streams = hlsparse(self.config, self.http.request("get", i["url"]), i["url"]) if streams: for n in list(streams.keys()): yield streams[n] else: match = re.search(r"var mediaConfig\s+= ({[^;]+);", self.get_urldata()) if not match: yield ServiceError("Cant find any media on that page") return janson = json.loads(match.group(1)) try: apiurl = janson["vpm"]["mediaFramework"]["mediaFrameworkDomain"] except KeyError: yield ServiceError("Can't find api url") return filename = "{}?contentId={}&playbackScenario=HTTP_CLOUD_WIRED_WEB&format=json&platform=WEB_MEDIAPLAYER" "&_=1487455224334".format( janson["vpm"]["mediaFramework"]["mediaFrameworkEndPoint"], vid, ) url = urljoin(apiurl, filename) res = self.http.get(url) janson = res.json() for i in janson["user_verified_event"][0]["user_verified_content"][0]["user_verified_media_item"]: streams = hlsparse(self.config, self.http.request("get", i["url"]), i["url"], output=self.output) for n in list(streams.keys()): yield streams[n]
def get(self): data = self.get_urldata() match = re.search('data-player-config="([^"]+)"', data) if not match: match = re.search('data-svpPlayer-video="([^"]+)"', data) if not match: yield ServiceError("Can't find video info") return data = json.loads(decode_html_entities(match.group(1))) streams = hlsparse(self.config, self.http.request("get", data["streamUrls"]["hls"]), data["streamUrls"]["hls"], output=self.output) for n in list(streams.keys()): yield streams[n]
def _get_video(self, janson): if "subtitleReferences" in janson: for i in janson["subtitleReferences"]: if i["format"] == "webvtt" and "url" in i: yield subtitle(copy.copy(self.config), "wrst", i["url"], output=self.output) if "videoReferences" in janson: if len(janson["videoReferences"]) == 0: yield ServiceError("Media doesn't have any associated videos.") return for i in janson["videoReferences"]: streams = None alt_streams = None alt = None query = parse_qs(urlparse(i["url"]).query) if "alt" in query and len(query["alt"]) > 0: alt = self.http.get(query["alt"][0]) if i["format"][:3] == "hls": streams = hlsparse(self.config, self.http.request("get", i["url"]), i["url"], output=self.output) if alt: alt_streams = hlsparse(self.config, self.http.request( "get", alt.request.url), alt.request.url, output=self.output) elif i["format"][:4] == "dash": streams = dashparse(self.config, self.http.request("get", i["url"]), i["url"], output=self.output) if alt: alt_streams = dashparse(self.config, self.http.request( "get", alt.request.url), alt.request.url, output=self.output) if streams: for n in list(streams.keys()): yield streams[n] if alt_streams: for n in list(alt_streams.keys()): yield alt_streams[n]
def get(self): data = self.get_urldata() match = re.search(r'id="(bcPl[^"]+)"', data) if not match: yield ServiceError("Can't find flash id.") return flashid = match.group(1) match = re.search(r'playerID" value="([^"]+)"', self.get_urldata()) if not match: yield ServiceError("Can't find playerID") return playerid = match.group(1) match = re.search(r'playerKey" value="([^"]+)"', self.get_urldata()) if not match: yield ServiceError("Can't find playerKey") return playerkey = match.group(1) match = re.search(r'videoPlayer" value="([^"]+)"', self.get_urldata()) if not match: yield ServiceError("Can't find videoPlayer info") return videoplayer = match.group(1) dataurl = ( "http://c.brightcove.com/services/viewer/htmlFederated?flashID={}&playerID={}&playerKey={}" "&isVid=true&isUI=true&dynamicStreaming=true&@videoPlayer={}".format(flashid, playerid, playerkey, videoplayer) ) data = self.http.request("get", dataurl).content match = re.search(r"experienceJSON = ({.*});", data) if not match: yield ServiceError("Can't find json data") return jsondata = json.loads(match.group(1)) renditions = jsondata["data"]["programmedContent"]["videoPlayer"]["mediaDTO"]["renditions"] if jsondata["data"]["publisherType"] == "PREMIUM": yield ServiceError("Premium content") return for i in renditions: if i["defaultURL"].endswith("f4m"): streams = hdsparse( copy.copy(self.config), self.http.request("get", i["defaultURL"], params={"hdcore": "3.7.0"}), i["defaultURL"], output=self.output ) for n in list(streams.keys()): yield streams[n] if i["defaultURL"].endswith("m3u8"): streams = hlsparse(self.config, self.http.request("get", i["defaultURL"]), i["defaultURL"], output=self.output) for n in list(streams.keys()): yield streams[n] if i["defaultURL"].endswith("mp4"): yield HTTP(copy.copy(self.config), i["defaultURL"], i["encodingRate"] / 1024, output=self.output)
def hlsparse(options, res, url): streams = {} if not res: return None if res.status_code > 400: streams[0] = ServiceError("Can't read HLS playlist. {0}".format( res.status_code)) return streams files = (parsem3u(res.text))[1] for i in files: try: bitrate = float(i[1]["BANDWIDTH"]) / 1000 except KeyError: streams[0] = ServiceError("Can't read HLS playlist") return streams streams[int(bitrate)] = HLS(copy.copy(options), _get_full_url(i[0], url), bitrate, cookies=res.cookies) return streams
def get(self): parse = urlparse(self.url) if parse.netloc == "www.svtplay.se" or parse.netloc == "svtplay.se": if parse.path[:6] != "/video" and parse.path[:6] != "/klipp" and parse.path[:8] != "/kanaler": yield ServiceError("This mode is not supported anymore. Need the url with the video.") return query = parse_qs(parse.query) self.access = None if "accessService" in query: self.access = query["accessService"] urldata = self.get_urldata() if parse.path[:8] == "/kanaler": match = re.search('data-video-id="([\\w-]+)"', urldata) if not match: yield ServiceError("Can't find video info.") return _url = urljoin(URL_VIDEO_API, match.group(1)) res = self.http.get(_url) try: janson = res.json() except json.decoder.JSONDecodeError: yield ServiceError("Can't decode api request: {}".format(res.request.url)) return videos = self._get_video(janson) self.config.set("live", True) yield from videos return match = re.search(r"__svtplay_apollo'] = ({.*});", urldata) if not match: yield ServiceError("Can't find video info.") return janson = json.loads(match.group(1)) self.visibleid = self._get_visibleid(janson) if not self.visibleid: yield ServiceError("Can't find video id") return vid = janson[self.visibleid]["videoSvtId"] self.outputfilename(janson) self.extrametadata(janson, self.visibleid) res = self.http.get(URL_VIDEO_API + vid) try: janson = res.json() except json.decoder.JSONDecodeError: yield ServiceError("Can't decode api request: {}".format(res.request.url)) return videos = self._get_video(janson) yield from videos
def get(self): parse = urlparse(self.url) if not parse.path.startswith("/video"): yield ServiceError("Can't find video info") return wanted_id = parse.path[7:] current_time = int( (datetime.utcnow() - datetime.utcfromtimestamp(0)).total_seconds() * 1000) api_url = "https://www.atgplay.se/api/{}/video/{}".format( current_time, wanted_id) video_assets = self.http.request("get", api_url) try: janson = json.loads(video_assets.text) except json.decoder.JSONDecodeError: yield ServiceError("Can't decode api request: {}".format( video_assets.text)) return if "title" in janson: self.output["title"] = janson["title"] if "urls" in janson: for i in janson["urls"]: if "m3u" == i: stream = hlsparse(self.config, self.http.request( "get", janson["urls"]["m3u"]), janson["urls"]["m3u"], output=self.output) for key in list(stream.keys()): yield stream[key]
def get(self): data = self.get_urldata() match = re.search(r'"([^"]+geo.php)"', data) if match: data = self.http.request("get", match.group(1)).content match = re.search(r"punktur=\(([^ ]+)\)", data) if match: janson = json.loads(match.group(1)) self.config.get("live", checklive(janson["result"][1])) streams = hlsparse(self.config, self.http.request("get", janson["result"][1]), janson["result"][1], output=self.output) for n in list(streams.keys()): yield streams[n] else: yield ServiceError("Can't find json info") else: match = re.search(r'<source [^ ]*[ ]*src="([^"]+)" ', self.get_urldata()) if not match: yield ServiceError("Can't find video info for: %s" % self.url) return if match.group(1).endswith("mp4"): yield HTTP(copy.copy(self.config), match.group(1), 800, output=self.output) else: m3u8_url = match.group(1) self.config.set("live", checklive(m3u8_url)) yield HLS(copy.copy(self.config), m3u8_url, 800, output=self.output)
def get(self): match = re.search(r"[\/-](\d+)$", self.url) if not match: yield ServiceError("Cant find video id") return self.output["id"] = match.group(1) match = re.search("data-program-format='([^']+)'", self.get_urldata()) if not match: yield ServiceError("Cant find program name") return self.output["title"] = match.group(1) match = re.search('img alt="([^"]+)" class="video-image responsive"', self.get_urldata()) if not match: yield ServiceError("Cant find title of the video") return self.output["episodename"] = match.group(1) url = "https://playback-api.b17g.net/media/{}?service=tv4&device=browser&protocol=hls%2Cdash&drm=widevine".format( self.output["id"]) res = self.http.request("get", url, cookies=self.cookies) if res.status_code > 200: yield ServiceError( "Can't play this because the video is geoblocked.") return if res.json()["playbackItem"]["type"] == "hls": streams = hlsparse( self.config, self.http.request("get", res.json()["playbackItem"]["manifestUrl"]), res.json()["playbackItem"]["manifestUrl"], output=self.output, ) for n in list(streams.keys()): yield streams[n]
def get(self): data = self.get_urldata() if self.exclude(): yield ServiceError("Excluding video") return match = re.search( r'script async defer src="(//content.youplay.se[^"]+)"', data) if not match: yield ServiceError("Cant find video info for {0}".format(self.url)) return data = self.http.request("get", "http:{0}".format(match.group(1)).content) match = re.search(r'decodeURIComponent\("([^"]+)"\)\)', data) if not match: yield ServiceError("Can't decode video info") return data = unquote_plus(match.group(1)) match = re.search(r"videoData = ({[^;]+});", data) if not match: yield ServiceError("Cant find video info for {0}".format(self.url)) return # fix broken json. regex = re.compile(r"\s(\w+):") data = regex.sub(r"'\1':", match.group(1)) data = data.replace("'", "\"") j = re.sub(r"{\s*(\w)", r'{"\1', data) j = j.replace("\n", "") j = re.sub(r'",\s*}', '"}', j) jsondata = json.loads(j) for i in jsondata["episode"]["sources"]: match = re.search(r"mp4_(\d+)", i) if match: yield HTTP(copy.copy(self.options), jsondata["episode"]["sources"][i], match.group(1))
def get(self): vid = None data = self.get_urldata() if self.exclude(): yield ServiceError("Excluding video") return match = re.search(r'video url-([^"]+)', data) if not match: match = re.search(r'embed.jsp\?([^"]+)"', self.get_urldata()) if not match: yield ServiceError("Can't find video id") return vid = match.group(1) if not vid: path = unquote_plus(match.group(1)) data = self.http.request("get", "http://www.svd.se%s" % path).content match = re.search(r'embed.jsp\?([^"]+)', data) if not match: yield ServiceError("Can't find video id") return vid = match.group(1) url = "http://ljsp.lwcdn.com/web/public/item.json?type=video&%s" % decode_html_entities( vid) data = self.http.request("get", url).text jdata = json.loads(data) videos = jdata["videos"][0]["media"]["streams"] for i in videos: if i["name"] == "auto": hls = "%s%s" % (jdata["videos"][0]["media"]["base"], i["url"]) streams = hlsparse(self.options, self.http.request("get", hls), hls) if streams: for n in list(streams.keys()): yield streams[n]
def get(self): data = self.get_urldata() match = re.search(r'data-videoid="([^"]+)"', data) if not match: parse = urlparse(self.url) match = re.search(r'video/(\d+)/', parse.fragment) if not match: yield ServiceError("Can't find video file for: %s" % self.url) return videoid = match.group(1) data = self.http.request("get", "http://svp.vg.no/svp/api/v1/vgtv/assets/%s?appName=vgtv-website" % videoid).text jsondata = json.loads(data) if self.options.output_auto: directory = os.path.dirname(self.options.output) title = "%s" % jsondata["title"] title = filenamify(title) if len(directory): self.options.output = os.path.join(directory, title) else: self.options.output = title if self.exclude(): yield ServiceError("Excluding video") return if "hds" in jsondata["streamUrls"]: streams = hdsparse(self.options, self.http.request("get", jsondata["streamUrls"]["hds"], params={"hdcore": "3.7.0"}), jsondata["streamUrls"]["hds"]) if streams: for n in list(streams.keys()): yield streams[n] if "hls" in jsondata["streamUrls"]: streams = hlsparse(self.options, self.http.request("get", jsondata["streamUrls"]["hls"]), jsondata["streamUrls"]["hls"]) for n in list(streams.keys()): yield streams[n] if "mp4" in jsondata["streamUrls"]: yield HTTP(copy.copy(self.options), jsondata["streamUrls"]["mp4"])
def get(self): match = re.search(r'/Player/Player" data-react-props="([^\"]+)\"', self.get_urldata()) if not match: yield ServiceError("Can't find json info") return data = unescape(match.group(1)) jsondata = json.loads(data) res = self.http.get( "https://streaming-loadbalancer.ur.se/loadbalancer.json") loadbalancer = res.json()["redirect"] for streaminfo in jsondata["currentProduct"]["streamingInfo"].keys(): stream = jsondata["currentProduct"]["streamingInfo"][streaminfo] if streaminfo == "raw": url = "https://{}/{}playlist.m3u8".format( loadbalancer, stream["sd"]["location"]) streams = hlsparse(self.config, self.http.request("get", url), url, output=self.output) for n in list(streams.keys()): yield streams[n] url = "https://{}/{}playlist.m3u8".format( loadbalancer, stream["hd"]["location"]) streams = hlsparse(self.config, self.http.request("get", url), url, output=self.output) for n in list(streams.keys()): yield streams[n] if not (self.config.get("get_all_subtitles")) and ( stream["default"]): yield subtitle(copy.copy(self.config), "tt", stream["tt"]["location"], output=self.output) if self.config.get("get_all_subtitles") and "tt" in stream: label = stream["tt"]["language"] if stream["tt"]["scope"] != "complete": label = "{}-{}".format(label, stream["tt"]["scope"]) yield subtitle(copy.copy(self.config), "tt", stream["tt"]["location"], label, output=self.output)