def test_failure_schema(self):
with pytest.raises(validate.ValidationError) as cm:
validate.validate(validate.startswith("invalid"), 1)
assert_validationerror(
cm.value, """
ValidationError(type):
Type of 1 should be str, but is int
""")
def test_failure(self):
with pytest.raises(validate.ValidationError) as cm:
validate.validate(validate.startswith("invalid"), "foo bar baz")
assert_validationerror(
cm.value, """
ValidationError(startswith):
'foo bar baz' does not start with 'invalid'
""")
def _get_streams(self):
self._get_cookies()
self.follow_vk_redirect()
video_id = self.match.group("video_id")
if not video_id:
return
log.debug(f"Video ID: {video_id}")
try:
data = self.session.http.post(
self.API_URL,
params={"act": "show"},
data={
"act": "show",
"al": "1",
"video": video_id
},
headers={"Referer": self.url},
schema=validate.Schema(
validate.transform(
lambda text: re.sub(r"^\s*<!--\s*", "", text)),
validate.parse_json(), {"payload": list},
validate.get(("payload", -1)), list, validate.get(-1),
{"player": {
"params": [dict]
}}, validate.get(("player", "params", 0)), {
validate.optional("hls"): validate.url(),
validate.optional("manifest"):
validate.startswith("<?xml"),
validate.optional("md_author"): validate.any(
str, None),
validate.optional("md_title"): validate.any(str, None),
}))
except PluginError:
log.error("Could not parse API response")
return
self.id = video_id
self.author = data.get("md_author")
self.title = data.get("md_title")
hls = data.get("hls")
if hls:
return HLSStream.parse_variant_playlist(self.session, hls)
dash_manifest = data.get("manifest")
if dash_manifest:
return DASHStream.parse_manifest(self.session, dash_manifest)
_swf_player_re = re.compile(
r'swfobject.embedSWF\("(/\d+/swf/[0-9A-Za-z]+\.swf)"')
_schema = validate.Schema(
validate.any(
validate.all(u"<error></error>", validate.transform(lambda x: None)),
validate.all(
validate.transform(lambda s: s.split(";")), validate.length(3),
validate.union({
"server":
validate.all(validate.get(0), validate.text),
"token":
validate.all(
validate.get(1), validate.text,
validate.startswith(":mvnkey-"),
validate.transform(lambda s: s[len(":mvnkey-"):])),
"ingest":
validate.all(validate.get(2), validate.text)
}))))
class VaughnLive(Plugin):
@classmethod
def can_handle_url(cls, url):
return _url_re.match(url)
def _get_streams(self):
res = http.get(self.url)
match = _swf_player_re.search(res.text)
if match is None:
def test_startswith(self):
assert validate(startswith("abc"), "abcedf")
class SeeTV(Plugin):
_url_re = re.compile(r"""(http://seetv.tv/vse-tv-online/.*?)(#|$)""")
_api_url = "http://seetv.tv/get/player/{0}"
_main_source_re = re.compile(r'stream-active-main" rel="(\d+)"')
api_schema = validate.Schema(validate.any(
{
"status": False,
"text": validate.text
},
{
"status": True,
"file": validate.any(
validate.all(validate.url(), validate.transform(lambda x: x.replace("%3F", "?"))),
validate.all(validate.text, validate.startswith("<"))
),
"height": validate.text,
}
))
@classmethod
def can_handle_url(cls, url):
return cls._url_re.match(url) is not None
@property
def referer(self):
return self._url_re.match(self.url).group(1)
def _get_tv_link(self):
res = self.session.http.get(self.url)
link_m = self._main_source_re.search(res.text)
return link_m and link_m.group(1)
def _get_streams(self):
self.session.http.headers.update({"User-Agent": useragents.CHROME,
"Referer": self.referer})
fragment = dict(parse_qsl(urlparse(self.url).fragment))
link = fragment.get("link")
if not link:
link = self._get_tv_link()
if not link:
self.logger.error("Missing link fragment: stream unavailable")
return
player_url = self._api_url.format(link)
self.logger.debug("Requesting player API: {0} (referer={1})", player_url, self.referer)
res = self.session.http.get(player_url,
params={"_": int(time.time() * 1000)},
headers={"X-Requested-With": "XMLHttpRequest"})
try:
data = self.session.http.json(res, schema=self.api_schema)
except PluginError as e:
print(e)
self.logger.error("Cannot play this stream type")
else:
if data["status"]:
if data["file"].startswith("<"):
self.logger.error("Cannot play embedded streams")
else:
return HLSStream.parse_variant_playlist(self.session, data["file"])
else:
self.logger.error(data["text"])
def test_startswith(self):
assert validate(startswith("abc"), "abcedf")
def test_success(self):
assert validate.validate(validate.startswith("foo"), "foo bar baz")
