def test_url_master(self):
session = Streamlink()
stream = HLSStream(session, "http://mocked/foo", url_master="http://mocked/master.m3u8")
assert stream.multivariant is None
assert stream.url == "http://mocked/foo"
assert stream.url_master == "http://mocked/master.m3u8"
def start(self, *mocked, **params):
with requests_mock.Mocker() as mock:
mocked_users = mock.get(
"https://api.twitch.tv/kraken/users.json?login=foo",
json={"users": [{
"_id": 1234
}]})
mocked_stream = mock.get(
"https://api.twitch.tv/kraken/streams/1234.json",
json={"stream": None} if params.pop("offline", False) else {
"stream": {
"stream_type":
params.pop("stream_type", "live"),
"broadcast_platform":
params.pop("broadcast_platform", "live"),
"channel": {
"broadcaster_software":
params.pop("broadcaster_software", "")
}
}
})
session = Streamlink()
Twitch.bind(session, "tests.plugins.test_twitch")
plugin = Twitch("https://www.twitch.tv/foo")
plugin.options.set("disable-reruns", params.pop("disable", True))
try:
streams = plugin.streams()
except TestTwitchReruns.StopError:
streams = True
pass
return streams, mocked_users, mocked_stream, mocked[0]
def __init__(self):
self.session = Streamlink()
self.session.set_loglevel("debug")
self.plugin = self.session.get_plugins()['crunchyroll']('')
self.plugin.options.set('username', USER)
self.plugin.options.set('password', PASS)
self.api = self.plugin._create_api()
self.search_candidates = None
def test_repr(self):
session = Streamlink()
stream = HLSStream(session, "https://foo.bar/playlist.m3u8")
self.assertEqual(repr(stream), "<HLSStream ['hls', 'https://foo.bar/playlist.m3u8']>")
stream = HLSStream(session, "https://foo.bar/playlist.m3u8", "https://foo.bar/master.m3u8")
self.assertEqual(repr(stream), "<HLSStream ['hls', 'https://foo.bar/playlist.m3u8', 'https://foo.bar/master.m3u8']>")
def run_streamlink(self, playlist, audio_select=None):
streamlink = Streamlink()
if audio_select:
streamlink.set_option("hls-audio-select", audio_select)
master_stream = hls.HLSStream.parse_variant_playlist(streamlink, playlist)
return master_stream
def subject(self, playlist, options=None):
with requests_mock.Mocker() as mock:
url = "http://mocked/{0}/master.m3u8".format(self.id())
content = self.get_master_playlist(playlist)
mock.get(url, text=content)
session = Streamlink(options)
return hls.HLSStream.parse_variant_playlist(session, url)
def subject(self, argv):
session = Streamlink()
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugin"))
with patch("streamlink_cli.main.streamlink", session), patch("sys.argv") as mock_argv:
mock_argv.__getitem__.side_effect = lambda x: argv[x]
try:
streamlink_cli.main.main()
except SystemExit:
pass
def streams(url, **params):
"""Attempts to find a plugin and extract streams from the *url*.
*params* are passed to :func:`Plugin.streams`.
Raises :exc:`NoPluginError` if no plugin is found.
"""
session = Streamlink()
return session.streams(url, **params)
def streams(url: str, **params):
"""
Initializes an empty Streamlink session, attempts to find a plugin and extracts streams from the URL if a plugin was found.
:param url: a URL to match against loaded plugins
:param params: Additional keyword arguments passed to :meth:`streamlink.Streamlink.streams`
:raises NoPluginError: on plugin resolve failure
:returns: A :class:`dict` of stream names and :class:`streamlink.stream.Stream` instances
"""
session = Streamlink()
return session.streams(url, **params)
def start_streamlink(self, masterPlaylist, kwargs=None):
kwargs = kwargs or {}
log.info("Executing streamlink")
streamlink = Streamlink()
# Set to default value to avoid a test fail if the default change
streamlink.set_option("hls-live-edge", 3)
masterStream = hls.HLSStream.parse_variant_playlist(streamlink, masterPlaylist, **kwargs)
stream = masterStream["1080p (source)"].open()
data = b"".join(iter(partial(stream.read, 8192), b""))
stream.close()
log.info("End of streamlink execution")
return data
def start_streamlink(self, disable_ads=False, low_latency=False, kwargs=None):
kwargs = kwargs or {}
log.info("Executing streamlink")
streamlink = Streamlink()
streamlink.set_option("hls-live-edge", 4)
streamlink.set_plugin_option("twitch", "disable-ads", disable_ads)
streamlink.set_plugin_option("twitch", "low-latency", low_latency)
masterStream = TwitchHLSStream.parse_variant_playlist(streamlink, self.url_master, **kwargs)
stream = masterStream["1080p (source)"].open()
data = b"".join(iter(partial(stream.read, 8192), b""))
stream.close()
log.info("End of streamlink execution")
return streamlink, data
def start_streamlink(self, kwargs=None):
kwargs = kwargs or {}
log.info("Executing streamlink")
streamlink = Streamlink()
streamlink.set_option("hls-live-edge", 4)
streamlink.plugins.get("twitch").options.set("disable-ads", True)
masterStream = TwitchHLSStream.parse_variant_playlist(
streamlink, "http://mocked/path/master.m3u8", **kwargs)
stream = masterStream["1080p (source)"].open()
data = b"".join(iter(partial(stream.read, 8192), b""))
stream.close()
log.info("End of streamlink execution")
return data
def __init__(self):
Thread.__init__(self)
self.daemon = True
session = Streamlink()
session.set_option("hls-live-edge", 2)
session.set_option("hls-timeout", 0)
session.set_option("stream-timeout", 0)
self.read_wait = Event()
self.read_done = Event()
self.data = []
self.error = None
self.stream = HLSStream(session, TestFilteredHLSStream.url_playlist)
self.reader = _TestSubjectFilteredHLSReader(self.stream)
self.reader.open()
def subject(cls, argv, **kwargs):
session = Streamlink()
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugin"))
with patch("streamlink_cli.main.os.geteuid", create=True, new=Mock(return_value=kwargs.get("euid", 1000))), \
patch("streamlink_cli.main.streamlink", session), \
patch("streamlink_cli.main.setup_signals", side_effect=cls.StopTest), \
patch("streamlink_cli.main.CONFIG_FILES", []), \
patch("streamlink_cli.main.setup_streamlink"), \
patch("streamlink_cli.main.setup_plugins"), \
patch("streamlink_cli.main.setup_http_session"), \
patch("streamlink.session.Streamlink.load_builtin_plugins"), \
patch("sys.argv") as mock_argv:
mock_argv.__getitem__.side_effect = lambda x: argv[x]
try:
streamlink_cli.main.main()
except cls.StopTest:
pass
def subject(self):
with patch.object(Streamlink, "load_builtin_plugins"), \
patch.object(Streamlink, "resolve_url") as mock_resolve_url, \
patch.object(Streamlink, "resolve_url_no_redirect") as mock_resolve_url_no_redirect:
session = Streamlink()
session.load_plugins(
os.path.join(os.path.dirname(__file__), "plugin"))
with patch("streamlink_cli.main.streamlink", session), \
patch("streamlink_cli.main.CONFIG_FILES", []), \
patch("streamlink_cli.main.setup_streamlink"), \
patch("streamlink_cli.main.setup_plugins"), \
patch("streamlink_cli.main.setup_http_session"), \
patch("streamlink_cli.main.setup_signals"), \
patch("streamlink_cli.main.setup_options") as mock_setup_options:
with self.assertRaises(SystemExit) as cm:
streamlink_cli.main.main()
self.assertEqual(cm.exception.code, 0)
mock_resolve_url.assert_not_called()
mock_resolve_url_no_redirect.assert_not_called()
mock_setup_options.assert_not_called()
def subject(cls, argv, **kwargs):
session = Streamlink()
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugin"))
# stop test execution at the setup_signals() call, as we're not interested in what comes afterwards
class StopTest(Exception):
pass
with patch("streamlink_cli.main.streamlink", session), \
patch("streamlink_cli.main.setup_signals", side_effect=StopTest), \
patch("streamlink_cli.main.CONFIG_FILES", []), \
patch("streamlink_cli.main.setup_streamlink"), \
patch("streamlink_cli.main.setup_plugins"), \
patch("streamlink_cli.main.setup_http_session"), \
patch("streamlink.session.Streamlink.load_builtin_plugins"), \
patch("sys.argv") as mock_argv:
mock_argv.__getitem__.side_effect = lambda x: argv[x]
try:
streamlink_cli.main.main()
except StopTest:
pass
def start_streamlink(self, data, reload_time):
streamlink = Streamlink()
streamlink.set_option("hls-playlist-reload-time", reload_time)
streamlink.set_option("hls-live-edge", 3)
streams = [
b""
for i in itertools.chain.from_iterable([elem[3] for elem in data])
]
playlists = [self.getPlaylist(*args) for args in data]
with requests_mock.Mocker() as mock:
mock.get(self.url_playlist, [{"text": p} for p in playlists])
for i, stream in enumerate(streams):
mock.get(self.url_segment.format(i), content=stream)
hlsstream = hls.HLSStream(streamlink, self.url_playlist)
reader = hlsstream.open()
reader.close()
return reader
def subject(cls, argv):
session = Streamlink()
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugin"))
def _log_current_arguments(*args, **kwargs):
log_current_arguments(*args, **kwargs)
raise SystemExit
with patch("streamlink_cli.main.streamlink", session), \
patch("streamlink_cli.main.log_current_arguments", side_effect=_log_current_arguments), \
patch("streamlink_cli.main.CONFIG_FILES", []), \
patch("streamlink_cli.main.setup_signals"), \
patch("streamlink_cli.main.setup_streamlink"), \
patch("streamlink_cli.main.setup_plugins"), \
patch("streamlink_cli.main.setup_http_session"), \
patch("streamlink.session.Streamlink.load_builtin_plugins"), \
patch("sys.argv") as mock_argv:
mock_argv.__getitem__.side_effect = lambda x: argv[x]
try:
streamlink_cli.main.main()
except SystemExit:
pass
from streamlink.session import Streamlink
slink = Streamlink()
#links = slink.streams("https://www.youtube.com/watch?v=xEzycp1HL8g")
#links = slink.streams("http://www.adulttvlive.net/channels/russianntv.php")
links = slink.streams("https://www.filmon.com/tv/bbc-one")
#links = slink.streams("https://www.filmon.com/channel/sat-1-schweiz")
#links = slink.streams("https://embedlive.flexmmp.com/live/livestream.php?ch=tv8&id=2")
#links = slink.streams("https://chaturbate.com/lettali/")
#links = slink.streams("http://patbuweb.com/iptv/e2liste/Canale-5")
#links = slink.streams("https://brittv.co.uk/watch/?channel=1")
print "links =", links
def setUp(self):
self.session = Streamlink()