def _get_streams(self):
video_id = parse_qsd(urlparse(self.url).query).get("videoId")
player = BrightcovePlayer(self.session, self.match.group("account_id"), self.match.group("player_id"))
streams = dict(player.get_streams(video_id))
self.title = player.title
return streams
def __init__(self, url):
super().__init__(url)
match = self.match.groupdict()
parsed = urlparse(url)
self.params = parse_qsd(parsed.query)
self.subdomain = match.get("subdomain")
self.video_id = None
self.channel = None
self.clip_name = None
if self.subdomain == "player":
# pop-out player
if self.params.get("video"):
self.video_id = self.params["video"]
self.channel = self.params.get("channel")
elif self.subdomain == "clips":
# clip share URL
self.clip_name = match.get("channel")
else:
self.channel = match.get("channel") and match.get(
"channel").lower()
self.video_id = match.get("video_id") or match.get("videos_id")
self.clip_name = match.get("clip_name")
self.api = TwitchAPI(session=self.session)
self.usher = UsherService(session=self.session)
def _get_streams_delfi(self, src):
try:
data = self.session.http.get(src, schema=validate.Schema(
validate.parse_html(),
validate.xml_xpath_string(".//script[contains(text(),'embedJs.setAttribute(')][1]/text()"),
validate.any(None, validate.all(
validate.text,
validate.transform(re.compile(r"embedJs\.setAttribute\('src',\s*'(.+?)'").search),
validate.any(None, validate.all(
validate.get(1),
validate.transform(lambda url: parse_qsd(urlparse(url).fragment)),
{"stream": validate.text},
validate.get("stream"),
validate.parse_json(),
{"versions": [{
"hls": validate.text
}]},
validate.get("versions")
))
))
))
except PluginError:
log.error("Failed to get streams from iframe")
return
for stream in data:
src = update_scheme("https://", stream["hls"], force=False)
for s in HLSStream.parse_variant_playlist(self.session, src).items():
yield s
def test_parse_qsd(self):
self.assertEqual({
"test": "1",
"foo": "bar"
},
parse_qsd("test=1&foo=bar",
schema=validate.Schema({
"test": validate.text,
"foo": "bar"
})))
def _get_streams(self):
data = self.session.http.get(
self.url,
schema=validate.Schema(
validate.transform(self._re_json_base.search),
validate.any(
None,
validate.all(
validate.get("json"), validate.parse_json(), {
"cam": {
validate.text: {
"live_type": validate.text,
"html5_streamingdomain": validate.text,
"html5_streampath": validate.text,
"group": validate.text,
"location": validate.text,
"title": validate.text,
"liveon": validate.text,
"defaulttab": validate.text,
}
}
}, validate.get("cam")))))
if not data:
return
cam_name = parse_qsd(self.url).get("cam") or next(
iter(data.keys()), None)
cam_data = data.get(cam_name)
if not cam_data:
return
# exclude everything other than live video streams
if cam_data["live_type"] != "flashvideo" or cam_data[
"liveon"] != "true" or cam_data["defaulttab"] != "live":
return
log.debug("Found cam {0}".format(cam_name))
hls_domain = cam_data["html5_streamingdomain"]
hls_playpath = cam_data["html5_streampath"]
self.author = cam_data["group"]
self.category = cam_data["location"]
self.title = cam_data["title"]
if hls_playpath:
hls_url = update_scheme("https://",
"{0}{1}".format(hls_domain, hls_playpath))
for s in HLSStream.parse_variant_playlist(self.session,
hls_url).items():
yield s
def _get_streams(self):
channel = self.match.group("channel")
pdata = self.session.http.get(self.caronte_url.format(channel=channel),
acceptable_status=(200, 403, 404),
schema=self.caronte_schema)
gbx = self.session.http.get(self.gbx_url.format(channel=channel),
schema=self.gbx_schema)
if "code" in pdata:
log.error("error getting pdata: {}".format(pdata["code"]))
return
tokens = self.session.http.post(
pdata["cerbero"],
acceptable_status=(200, 403, 404),
json={
"bbx": pdata["bbx"],
"gbx": gbx
},
headers={"origin": "https://www.mitele.es"},
schema=self.cerbero_schema)
if "code" in tokens:
log.error("Could not get stream tokens: {} ({})".format(
tokens["code"],
self.token_errors.get(tokens["code"], "unknown error")))
return
list_urls = []
for stream in pdata["dls"]:
if stream["drm"]:
log.warning("Stream may be protected by DRM")
else:
sformat = stream.get("format")
log.debug("Stream: {} ({})".format(stream["stream"], sformat
or "n/a"))
cdn_token = tokens.get(stream["lid"], {}).get("cdn", "")
qsd = parse_qsd(cdn_token)
if sformat == "hls":
list_urls.append(update_qsd(stream["stream"], qsd))
if not list_urls:
return
for url in list(set(list_urls)):
for s in HLSStream.parse_variant_playlist(
self.session, url, name_fmt="{pixels}_{bitrate}").items():
yield s
def _get_streams(self):
if not self.matches[0]:
self._domain = urlparse(self.url).netloc
iframes = self.session.http.get(
self.url,
schema=validate.Schema(
validate.parse_html(),
validate.xml_findall(".//iframe[@src]"),
validate.filter(lambda elem: urlparse(
elem.attrib.get("src")).netloc == "ott.streann.com")))
if not iframes:
log.error("Could not find 'ott.streann.com' iframe")
return
self.url = iframes[0].attrib.get("src")
if not self._domain and self.get_option("url"):
self._domain = urlparse(self.get_option("url")).netloc
if self._domain is None:
log.error("Missing source URL, use --streann-url")
return
self.session.http.headers.update({"Referer": self.url})
# Get the query string
encrypted_data = urlparse(self.url).query
data = base64.b64decode(encrypted_data)
# and decrypt it
passphrase = self.passphrase()
if passphrase:
log.debug("Found passphrase")
params = decrypt_openssl(data, passphrase)
config = parse_qsd(params.decode("utf8"))
log.trace("config: {0!r}".format(config))
token = self.get_token(**config)
if not token:
return
hls_url = self.stream_url.format(time=self.time,
deviceId=self.device_id,
token=token,
**config)
log.debug("URL={0}".format(hls_url))
return HLSStream.parse_variant_playlist(
self.session, hls_url, acceptable_status=(200, 403, 404, 500))
def _get_streams(self):
p = urlparse(self.url)
if "ott.streann.com" != p.netloc:
self._domain = p.netloc
res = self.session.http.get(self.url)
for iframe in itertags(res.text, "iframe"):
iframe_url = html_unescape(iframe.attributes.get("src"))
if "ott.streann.com" in iframe_url:
self.url = iframe_url
break
else:
log.error("Could not find 'ott.streann.com' iframe")
return
if not self._domain and self.get_option("url"):
self._domain = urlparse(self.get_option("url")).netloc
if self._domain is None:
log.error("Missing source URL use --streann-url")
return
self.session.http.headers.update({"Referer": self.url})
# Get the query string
encrypted_data = urlparse(self.url).query
data = base64.b64decode(encrypted_data)
# and decrypt it
passphrase = self.passphrase()
if passphrase:
log.debug("Found passphrase")
params = decrypt_openssl(data, passphrase)
config = parse_qsd(params.decode("utf8"))
log.trace(f"config: {config!r}")
token = self.get_token(**config)
if not token:
return
hls_url = self.stream_url.format(time=self.time,
deviceId=self.device_id,
token=token,
**config)
log.debug("URL={0}".format(hls_url))
return HLSStream.parse_variant_playlist(
self.session, hls_url, acceptable_status=(200, 403, 404, 500))
def __init__(self, url):
super(Twitch, self).__init__(url)
match = self.match.groupdict()
parsed = urlparse(url)
self.params = parse_qsd(parsed.query)
self.subdomain = match.get("subdomain")
self.video_id = None
self.channel = None
self.clip_name = None
self._checked_metadata = False
if self.subdomain == "player":
# pop-out player
if self.params.get("video"):
self.video_id = self.params["video"]
self.channel = self.params.get("channel")
elif self.subdomain == "clips":
# clip share URL
self.clip_name = match.get("channel")
else:
self.channel = match.get("channel") and match.get(
"channel").lower()
self.video_id = match.get("video_id") or match.get("videos_id")
self.clip_name = match.get("clip_name")
self.api = TwitchAPI(session=self.session)
self.usher = UsherService(session=self.session)
def method_factory(parent_method):
def inner():
if not self._checked_metadata:
self._checked_metadata = True
self._get_metadata()
return parent_method()
return inner
parent = super(Twitch, self)
for metadata in "id", "author", "category", "title":
method = "get_{0}".format(metadata)
setattr(self, method, method_factory(getattr(parent, method)))