class ard_live(Plugin):
swf_url = "http://live.daserste.de/lib/br-player/swf/main.swf"
_url_re = re.compile(r"https?://(www.)?daserste.de/", re.I)
_player_re = re.compile(r'''dataURL\s*:\s*(?P<q>['"])(?P<url>.*?)(?P=q)''')
_player_url_schema = validate.Schema(
validate.transform(_player_re.search),
validate.any(None, validate.all(validate.get("url"), validate.text)))
_livestream_schema = validate.Schema(
validate.xml_findall(".//assets"),
validate.filter(lambda x: x.attrib.get("type") != "subtitles"),
validate.get(0), validate.xml_findall(".//asset"), [
validate.union({
"url": validate.xml_findtext("./fileName"),
"bitrate": validate.xml_findtext("./bitrateVideo")
})
])
@classmethod
def can_handle_url(cls, url):
return cls._url_re.match(url) is not None
def _get_streams(self):
data_url = http.get(self.url, schema=self._player_url_schema)
if data_url:
res = http.get(urljoin(self.url, data_url))
stream_info = http.xml(res, schema=self._livestream_schema)
for stream in stream_info:
url = stream["url"]
try:
if ".m3u8" in url:
for s in HLSStream.parse_variant_playlist(
self.session, url, name_key="bitrate").items():
yield s
elif ".f4m" in url:
for s in HDSStream.parse_manifest(
self.session,
url,
pvswf=self.swf_url,
is_akamai=True).items():
yield s
elif ".mp4" in url:
yield "{0}k".format(stream["bitrate"]), HTTPStream(
self.session, url)
except IOError as err:
self.logger.warning("Error parsing stream: {0}", err)
class Rtve(Plugin):
secret_key = base64.b64decode("eWVMJmRhRDM=")
content_id_re = re.compile(r'data-id\s*=\s*"(\d+)"')
url_re = re.compile(
r"""
https?://(?:www\.)?rtve\.es/(?:directo|noticias|television|deportes|alacarta|drmn)/.*?/?
""", re.VERBOSE)
cdn_schema = validate.Schema(
validate.transform(partial(parse_xml, invalid_char_entities=True)),
validate.xml_findall(".//preset"), [
validate.union({
"quality":
validate.all(validate.getattr("attrib"), validate.get("type")),
"urls":
validate.all(validate.xml_findall(".//url"),
[validate.getattr("text")])
})
])
subtitles_api = "http://www.rtve.es/api/videos/{id}/subtitulos.json"
subtitles_schema = validate.Schema(
{"page": {
"items": [{
"src": validate.url(),
"lang": validate.text
}]
}}, validate.get("page"), validate.get("items"))
video_api = "http://www.rtve.es/api/videos/{id}.json"
video_schema = validate.Schema(
{
"page": {
"items": [{
"qualities": [{
"preset": validate.text,
"height": int
}]
}]
}
}, validate.get("page"), validate.get("items"), validate.get(0))
options = PluginOptions({"mux_subtitles": False})
@classmethod
def can_handle_url(cls, url):
return cls.url_re.match(url) is not None
def __init__(self, url):
Plugin.__init__(self, url)
self.zclient = ZTNRClient(self.secret_key)
http.headers = {"User-Agent": useragents.SAFARI_8}
def _get_content_id(self):
res = http.get(self.url)
m = self.content_id_re.search(res.text)
return m and int(m.group(1))
def _get_subtitles(self, content_id):
res = http.get(self.subtitles_api.format(id=content_id))
return http.json(res, schema=self.subtitles_schema)
def _get_quality_map(self, content_id):
res = http.get(self.video_api.format(id=content_id))
data = http.json(res, schema=self.video_schema)
qmap = {}
for item in data["qualities"]:
qname = {
"MED": "Media",
"HIGH": "Alta",
"ORIGINAL": "Original"
}.get(item["preset"], item["preset"])
qmap[qname] = u"{0}p".format(item["height"])
return qmap
def _get_streams(self):
streams = []
content_id = self._get_content_id()
if content_id:
self.logger.debug("Found content with id: {0}", content_id)
stream_data = self.zclient.get_cdn_list(content_id,
schema=self.cdn_schema)
quality_map = None
for stream in stream_data:
for url in stream["urls"]:
if url.endswith("m3u8"):
try:
streams.extend(
HLSStream.parse_variant_playlist(
self.session, url).items())
except (IOError, OSError):
self.logger.debug("Failed to load m3u8 url: {0}",
url)
elif ((url.endswith("mp4") or url.endswith("mov")
or url.endswith("avi"))
and http.head(
url, raise_for_status=False).status_code == 200):
if quality_map is None: # only make the request when it is necessary
quality_map = self._get_quality_map(content_id)
# rename the HTTP sources to match the HLS sources
quality = quality_map.get(stream["quality"],
stream["quality"])
streams.append((quality, HTTPStream(self.session,
url)))
subtitles = None
if self.get_option("mux_subtitles"):
subtitles = self._get_subtitles(content_id)
if subtitles:
substreams = {}
for i, subtitle in enumerate(subtitles):
substreams[subtitle["lang"]] = HTTPStream(
self.session, subtitle["src"])
for q, s in streams:
yield q, MuxedStream(self.session, s, subtitles=substreams)
else:
for s in streams:
yield s
/
(?P<video_type>[bcv])
/
(?P<video_id>\d+)
)?
(?:
/
(?P<clip_name>[\w]+)
)?
""", re.VERBOSE)
_access_token_schema = validate.Schema(
{
"token": validate.text,
"sig": validate.text
}, validate.union((validate.get("sig"), validate.get("token"))))
_token_schema = validate.Schema(
{
"chansub": {
"restricted_bitrates":
validate.all([validate.text],
validate.filter(lambda n: not re.match(
r"(.+_)?archives|live|chunked", n)))
}
}, validate.get("chansub"))
_user_schema = validate.Schema(
{validate.optional("display_name"): validate.text},
validate.get("display_name"))
_video_schema = validate.Schema({
"chunks": {
validate.text: [{
"geo_blocked": [],
"notes": "",
"live": True,
"vod": True,
"last_update": "2017-02-09",
}
_url_re = re.compile(r"https?://(?:www\.)?openrec.tv/(live|movie)/")
_playlist_url_re = re.compile(r"data-(source)?file=\"(?P<url>[^\"]+)\"")
_movie_data_re = re.compile(r'''<script type="application/ld\+json">(.*?)</script>''', re.DOTALL | re.M)
_live_schema = validate.Schema(
validate.transform(_playlist_url_re.findall),
[
validate.union({
"isSource": validate.all(validate.get(0), validate.transform(lambda s: s == "source")),
"url": validate.all(validate.get(1), validate.url(scheme="http",
path=validate.endswith(".m3u8")))
})
]
)
_movie_schema = validate.Schema(
validate.transform(_movie_data_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.transform(parse_json),
validate.get("contentUrl")
)
)
)
def test_union(self):
assert validate(union((get("foo"), get("bar"))), {
"foo": "alpha",
"bar": "beta"
}) == ("alpha", "beta")
_url_re = re.compile(
r"""
https?://(\w+\.)?aliez.\w+/
(?:live/[^/]+|video/\d+/[^/]+)
""", re.VERBOSE)
_file_re = re.compile(r"\"?file\"?:\s+['\"]([^'\"]+)['\"]")
_swf_url_re = re.compile(r"swfobject.embedSWF\(\"([^\"]+)\",")
_schema = validate.Schema(
validate.union({
"urls":
validate.all(validate.transform(_file_re.findall),
validate.map(unquote), [validate.url()]),
"swf":
validate.all(
validate.transform(_swf_url_re.search),
validate.any(
None,
validate.all(
validate.get(1),
validate.url(scheme="http",
path=validate.endswith("swf")))))
}))
class Aliez(Plugin):
@classmethod
def can_handle_url(self, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url, schema=_schema)
})
_smil_schema = validate.Schema(validate.union({
"http_base": validate.all(
validate.xml_find("{http://www.w3.org/2001/SMIL20/Language}head/"
"{http://www.w3.org/2001/SMIL20/Language}meta"
"[@name='httpBase']"),
validate.xml_element(attrib={
"content": validate.text
}),
validate.get("content")
),
"videos": validate.all(
validate.xml_findall("{http://www.w3.org/2001/SMIL20/Language}body/"
"{http://www.w3.org/2001/SMIL20/Language}switch/"
"{http://www.w3.org/2001/SMIL20/Language}video"),
[
validate.all(
validate.xml_element(attrib={
"src": validate.text,
"system-bitrate": validate.all(
validate.text,
validate.transform(int)
)
}),
validate.transform(
lambda e: (e.attrib["src"], e.attrib["system-bitrate"])
)
)
],
)
}))
validate.union({
"export_url":
validate.all(validate.transform(_live_export_re.search),
validate.any(
None,
validate.get(1),
)),
"video_flashvars":
validate.all(
validate.transform(_video_flashvars_re.search),
validate.any(
None,
validate.all(
validate.get(1), validate.transform(parse_query), {
"_111pix_serverURL": validate.url(scheme="rtmp"),
"en_flash_providerName": validate.text
}))),
"history_video":
validate.all(
validate.transform(_history_re.search),
validate.any(
None, validate.all(validate.get(1),
validate.url(scheme="http")))),
"standby_video":
validate.all(
validate.transform(_replay_json_re.search),
validate.any(
None,
validate.all(validate.get(1), validate.transform(parse_json),
[{
"streamName": validate.url(scheme="http")
}])))
}))
"_mediaStreamArray": [{
validate.optional("_server"):
validate.text,
"_stream":
validate.any(validate.text, [validate.text]),
"_quality":
validate.any(int, validate.text)
}]
}]
})
_smil_schema = validate.Schema(
validate.union({
"base":
validate.all(validate.xml_find("head/meta"), validate.get("base"),
validate.url(scheme="http")),
"cdn":
validate.all(validate.xml_find("head/meta"), validate.get("cdn")),
"videos":
validate.all(validate.xml_findall("body/seq/video"),
[validate.get("src")])
}))
class ard_mediathek(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_http_streams(self, info):
name = QUALITY_MAP.get(info["_quality"], "vod")
urls = info["_stream"]
if not isinstance(info["_stream"], list):
}
STREAM_INFO_URL = "https://api.periscope.tv/api/v2/getAccessPublic"
STATUS_GONE = 410
STATUS_UNAVAILABLE = (STATUS_GONE, )
_url_re = re.compile(
r"http(s)?://(www\.)?(periscope|pscp)\.tv/[^/]+/(?P<broadcast_id>[\w\-\=]+)"
)
_stream_schema = validate.Schema(
validate.any(
None,
validate.union({
"hls_url":
validate.all({"hls_url": validate.url(scheme="http")},
validate.get("hls_url")),
}),
validate.union({
"replay_url":
validate.all({"replay_url": validate.url(scheme="http")},
validate.get("replay_url")),
}),
), )
class Periscope(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
class Mixer(Plugin):
api_url = "https://mixer.com/api/v1/{type}/{id}"
_vod_schema = validate.Schema(
{
"state":
"AVAILABLE",
"vods": [{
"baseUrl": validate.url(),
"data": validate.any(None, {"Height": int}),
"format": validate.text
}]
}, validate.get("vods"),
validate.filter(lambda x: x["format"] in ("raw", "hls")), [
validate.union({
"url":
validate.get("baseUrl"),
"format":
validate.get("format"),
"height":
validate.all(validate.get("data"), validate.get("Height"))
})
])
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_api_res(self, api_type, api_id):
try:
res = http.get(self.api_url.format(type=api_type, id=api_id))
return res
except Exception as e:
if "404" in str(e):
self.logger.error("invalid {0} - {1}".format(api_type, api_id))
elif "429" in str(e):
self.logger.error(
"Too Many Requests, API rate limit exceeded.")
raise NoStreamsError(self.url)
def _get_vod_stream(self, vod_id):
res = self._get_api_res("recordings", vod_id)
for sdata in http.json(res, schema=self._vod_schema):
if sdata["format"] == "hls":
hls_url = urljoin(sdata["url"], "manifest.m3u8")
yield "{0}p".format(sdata["height"]), HLSStream(
self.session, hls_url)
def _get_live_stream(self, channel):
res = self._get_api_res("channels", channel)
channel_info = http.json(res)
if not channel_info["online"]:
return
user_id = channel_info["id"]
hls_url = self.api_url.format(type="channels",
id="{0}/manifest.m3u8".format(user_id))
for s in HLSStream.parse_variant_playlist(self.session,
hls_url).items():
yield s
def _get_streams(self):
params = dict(parse_qsl(urlparse(self.url).query))
vod_id = params.get("vod")
match = _url_re.match(self.url)
channel = match.group("channel")
if vod_id:
self.logger.debug("Looking for VOD {0} from channel: {1}", vod_id,
channel)
return self._get_vod_stream(vod_id)
else:
self.logger.debug("Looking for channel: {0}", channel)
return self._get_live_stream(channel)
_clientlibs_re = re.compile(r"""<script.*?src=(['"])(.*?/clientlibs_anime_watch.*?\.js)\1""")
_schema = validate.Schema(
validate.union({
"flashvars": validate.all(
validate.transform(_flashvars_re.search),
validate.get(1),
validate.transform(_flashvar_re.findall),
validate.map(lambda v: (v[1], v[3])),
validate.transform(dict),
{
"s": validate.text,
"country": validate.text,
"init": validate.text,
validate.optional("ss_id"): validate.text,
validate.optional("mv_id"): validate.text,
validate.optional("device_cd"): validate.text,
validate.optional("ss1_prm"): validate.text,
validate.optional("ss2_prm"): validate.text,
validate.optional("ss3_prm"): validate.text
}
),
"clientlibs": validate.all(
validate.transform(_clientlibs_re.search),
validate.get(2),
validate.text
)
})
)
_language_schema = validate.Schema(
class AnimeLab(Plugin):
url_re = re.compile(r"https?://(?:www\.)?animelab\.com/player/")
login_url = "https://www.animelab.com/login"
video_collection_re = re.compile(r"VideoCollection\((\[.*?\])\);")
playlist_position_re = re.compile(r"playlistPosition\s*=\s*(\d+);")
video_collection_schema = validate.Schema(
validate.union({
"position":
validate.all(
validate.transform(playlist_position_re.search),
validate.any(
None, validate.all(validate.get(1),
validate.transform(int)))),
"playlist":
validate.all(
validate.transform(video_collection_re.search),
validate.any(
None,
validate.all(validate.get(1),
validate.transform(parse_json))))
}))
options = PluginOptions({"email": None, "password": None})
@classmethod
def can_handle_url(cls, url):
return cls.url_re.match(url) is not None
def login(self, email, password):
self.logger.debug("Attempting to log in as {0}", email)
res = http.post(self.login_url,
data=dict(email=email, password=password),
allow_redirects=False,
raise_for_status=False)
loc = res.headers.get("Location", "")
if "geoblocked" in loc.lower():
self.logger.error("AnimeLab is not available in your territory")
elif res.status_code >= 400:
self.logger.error(
"Failed to login to AnimeLab, check your email/password combination"
)
else:
return True
return False
def _get_streams(self):
email, password = self.get_option("email"), self.get_option("password")
if not email or not password:
self.logger.error(
"AnimeLab requires authentication, use --animelab-email "
"and --animelab-password to set your email/password combination"
)
return
if self.login(email, password):
self.logger.info("Successfully logged in as {0}", email)
video_collection = http.get(self.url,
schema=self.video_collection_schema)
if video_collection["playlist"] is None or video_collection[
"position"] is None:
return
data = video_collection["playlist"][video_collection["position"]]
self.logger.debug("Found {0} version {1} hard-subs",
data["language"]["name"],
"with" if data["hardSubbed"] else "without")
for video in data["videoInstances"]:
if video["httpUrl"]:
q = video["videoQuality"]["description"]
s = HTTPStream(self.session, video["httpUrl"])
yield q, s
class WWENetwork(Plugin):
url_re = re.compile(r"https?://network.wwe.com")
content_id_re = re.compile(r'''"content_id" : "(\d+)"''')
playback_scenario = "HTTP_CLOUD_WIRED"
login_url = "https://secure.net.wwe.com/workflow.do"
login_page_url = "https://secure.net.wwe.com/enterworkflow.do?flowId=account.login&forwardUrl=http%3A%2F%2Fnetwork.wwe.com"
api_url = "https://ws.media.net.wwe.com/ws/media/mf/op-findUserVerifiedEvent/v-2.3"
_info_schema = validate.Schema(
validate.union({
"status": validate.union({
"code": validate.all(validate.xml_findtext(".//status-code"), validate.transform(int)),
"message": validate.xml_findtext(".//status-message"),
}),
"urls": validate.all(
validate.xml_findall(".//url"),
[validate.getattr("text")]
),
validate.optional("fingerprint"): validate.xml_findtext(".//updated-fingerprint"),
validate.optional("session_key"): validate.xml_findtext(".//session-key"),
"session_attributes": validate.all(
validate.xml_findall(".//session-attribute"),
[validate.getattr("attrib"),
validate.union({
"name": validate.get("name"),
"value": validate.get("value")
})]
)
})
)
options = PluginOptions({
"email": None,
"password": None,
})
def __init__(self, url):
super(WWENetwork, self).__init__(url)
http.headers.update({"User-Agent": useragents.CHROME})
self._session_attributes = Cache(filename="plugin-cache.json", key_prefix="wwenetwork:attributes")
self._session_key = self.cache.get("session_key")
self._authed = self._session_attributes.get("ipid") and self._session_attributes.get("fprt")
@classmethod
def can_handle_url(cls, url):
return cls.url_re.match(url) is not None
def login(self, email, password):
self.logger.debug("Attempting login as {0}", email)
# sets some required cookies to login
http.get(self.login_page_url)
# login
res = http.post(self.login_url, data=dict(registrationAction='identify',
emailAddress=email,
password=password,
submitButton=""),
headers={"Referer": self.login_page_url},
allow_redirects=False)
self._authed = "Authentication Error" not in res.text
if self._authed:
self._session_attributes.set("ipid", res.cookies.get("ipid"), expires=3600 * 1.5)
self._session_attributes.set("fprt", res.cookies.get("fprt"), expires=3600 * 1.5)
return self._authed
def _update_session_attribute(self, key, value):
if value:
self._session_attributes.set(key, value, expires=3600 * 1.5) # 1h30m expiry
http.cookies.set(key, value)
@property
def session_key(self):
return self._session_key
@session_key.setter
def session_key(self, value):
self.cache.set("session_key", value)
self._session_key = value
def _get_media_info(self, content_id):
"""
Get the info about the content, based on the ID
:param content_id:
:return:
"""
params = {"identityPointId": self._session_attributes.get("ipid"),
"fingerprint": self._session_attributes.get("fprt"),
"contentId": content_id,
"playbackScenario": self.playback_scenario,
"platform": "WEB_MEDIAPLAYER_5",
"subject": "LIVE_EVENT_COVERAGE",
"frameworkURL": "https://ws.media.net.wwe.com",
"_": int(time.time())}
if self.session_key:
params["sessionKey"] = self.session_key
url = self.api_url.format(id=content_id)
res = http.get(url, params=params)
return http.xml(res, ignore_ns=True, schema=self._info_schema)
def _get_content_id(self):
# check the page to find the contentId
res = http.get(self.url)
m = self.content_id_re.search(res.text)
if m:
return m.group(1)
def _get_streams(self):
email = self.get_option("email")
password = self.get_option("password")
if not self._authed and (not email and not password):
self.logger.error("A login for WWE Network is required, use --wwenetwork-email/"
"--wwenetwork-password to set them")
return
if not self._authed:
if not self.login(email, password):
self.logger.error("Failed to login, check your username/password")
return
content_id = self._get_content_id()
if content_id:
self.logger.debug("Found content ID: {0}", content_id)
info = self._get_media_info(content_id)
if info["status"]["code"] == 1:
# update the session attributes
self._update_session_attribute("fprt", info.get("fingerprint"))
for attr in info["session_attributes"]:
self._update_session_attribute(attr["name"], attr["value"])
if info.get("session_key"):
self.session_key = info.get("session_key")
for url in info["urls"]:
for s in HLSStream.parse_variant_playlist(self.session, url, name_fmt="{pixels}_{bitrate}").items():
yield s
else:
raise PluginError("Could not load streams: {message} ({code})".format(**info["status"]))
_url_re = re.compile(r"http(s)?://(\w+\.)?seemeplay.ru/")
_player_re = re.compile(
r"""
SMP.(channel|video).player.init\({
\s+file:\s+"([^"]+)"
""", re.VERBOSE)
_schema = validate.Schema(
validate.transform(_player_re.search),
validate.any(
None,
validate.union({
"type":
validate.get(1),
"url":
validate.all(
validate.get(2),
validate.url(scheme="http"),
),
})))
class SeeMePlay(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
