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 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 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, 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, masterPlaylist, kwargs={}):
print("Executing streamlink")
streamlink = Streamlink()
# Set to default value to avoid a test fail if the default change
streamlink.set_option("hls-live-edge", 3)
streamlink.logger.set_level("debug")
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()
print("End of streamlink execution")
return 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 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 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 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 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(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 __init__(self,
session: Streamlink,
url: str,
subprotocols: Optional[List[str]] = None,
header: Optional[Union[List[str], Dict[str, str]]] = None,
cookie: Optional[str] = None,
sockopt: Optional[Tuple] = None,
sslopt: Optional[Dict] = None,
host: Optional[str] = None,
origin: Optional[str] = None,
suppress_origin: bool = False,
ping_interval: Union[int, float] = 0,
ping_timeout: Optional[Union[int, float]] = None,
ping_payload: str = ""):
if rootlogger.level <= TRACE:
enableTrace(True, log)
if not header:
header = []
elif isinstance(header, dict):
header = [f"{str(k)}: {str(v)}" for k, v in header.items()]
if not any(True for h in header if h.startswith("User-Agent: ")):
header.append(
f"User-Agent: {str(session.http.headers['User-Agent'])}")
proxy_options: Dict[str, Any] = {}
http_proxy: Optional[str] = session.get_option("http-proxy")
if http_proxy:
p = urlparse(http_proxy)
proxy_options["proxy_type"] = p.scheme
proxy_options["http_proxy_host"] = p.hostname
if p.port: # pragma: no branch
proxy_options["http_proxy_port"] = p.port
if p.username: # pragma: no branch
proxy_options["http_proxy_auth"] = unquote_plus(
p.username), unquote_plus(p.password or "")
self._reconnect = False
self._reconnect_lock = RLock()
self.session = session
self._ws_init(url, subprotocols, header, cookie)
self._ws_rundata = dict(sockopt=sockopt,
sslopt=sslopt,
host=host,
origin=origin,
suppress_origin=suppress_origin,
ping_interval=ping_interval,
ping_timeout=ping_timeout,
ping_payload=ping_payload,
**proxy_options)
self._id += 1
super().__init__(name=f"Thread-{self.__class__.__name__}-{self._id}",
daemon=True)
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 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
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 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, 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
class CrunchyrollAPI(object):
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 list_series(self, media_type, filter, limit=None, offset=None):
""" Returns a list of series given filter constraints
"""
params = {
"media_type": media_type,
"filter": filter,
}
if limit:
params["limit"] = limit
if offset:
params["offset"] = offset
return self.api._api_call("list_series", params)
def list_collections(self, series_id, sort=None, limit=None, offset=None):
""" Returns a list of collections for a given series
"""
params = {
"series_id": series_id,
}
if sort:
params["sort"] = sort
if limit:
params["limit"] = limit
if offset:
params["offset"] = offset
return self.api._api_call("list_collections", params)
def list_media(self,
series_id,
sort=None,
limit=None,
offset=None,
locale=None):
""" Returns a list of media for a given series
"""
params = {
"series_id": series_id,
}
if sort:
params["sort"] = sort
if limit:
params["limit"] = limit
if offset:
params["offset"] = offset
if locale:
params["locale"] = locale
return self.api._api_call("list_media", params)
def list_search_candidates(self):
""" Returns a list of search candidates (Series)
"""
res = self.session.http.get(
'http://www.crunchyroll.com/ajax/?req=RpcApiSearch_GetSearchCandidates'
)
data = json.loads(res.text[len('/*-secure-'):-len('*/')])['data']
series = [elt for elt in data if elt['type'] == 'Series']
return series
def get_queue(self, media_types, fields=None):
""" Return queue
"""
params = {
"media_types": media_types,
}
if fields:
params["fields"] = fields
return self.api._api_call("queue", params)
def search(self, search_term):
results = []
if self.search_candidates == None:
self.search_candidates = self.list_search_candidates()
search_term = search_term.lower()
for series in self.search_candidates:
if search_term in series['name'].lower():
results.append(series)
return results
def remove_from_queue(self, series_id):
params = {"series_id": series_id}
return self.api._api_call("remove_from_queue", params)
class TestWebsocketClient(unittest.TestCase):
def setUp(self):
self.session = Streamlink()
def tearDown(self):
self.session = None
@patch("streamlink.plugin.api.websocket.enableTrace")
def test_log(self, mock_enable_trace: Mock):
with patch("streamlink.plugin.api.websocket.rootlogger", Mock(level=DEBUG)):
WebsocketClient(self.session, "wss://*****:*****@hostname:1234")
client = WebsocketClient(
self.session,
"wss://*****:*****@patch("streamlink.plugin.api.websocket.WebSocketApp")
def test_reconnect_disconnected(self, mock_wsapp: Mock):
client = WebsocketClient(self.session, "wss://*****:*****@patch("streamlink.plugin.api.websocket.WebSocketApp")
def test_reconnect_once(self, mock_wsapp: Mock):
client = WebsocketClient(self.session, "wss://localhost:0")
run_forever_entered = Event()
run_forever_ended = Event()
# noinspection PyUnusedLocal
def mock_run_forever(**data):
run_forever_entered.set()
run_forever_ended.wait(1)
run_forever_ended.clear()
client.ws.keep_running = True
client.ws.run_forever.side_effect = mock_run_forever
client.start()
self.assertEqual(client.ws.close.call_count, 0)
self.assertEqual(mock_wsapp.call_count, 1, "Creates initial connection")
self.assertFalse(client._reconnect, "Has not set the _reconnect state")
self.assertTrue(run_forever_entered.wait(1), "Enters run_forever loop on client thread")
run_forever_entered.clear()
client.reconnect()
self.assertEqual(client.ws.close.call_count, 1)
self.assertEqual(mock_wsapp.call_count, 2, "Creates new connection")
self.assertTrue(client._reconnect, "Has set the _reconnect state")
run_forever_ended.set()
self.assertTrue(run_forever_entered.wait(1), "Enters run_forever loop on client thread again")
self.assertFalse(client._reconnect, "Has reset the _reconnect state")
run_forever_ended.set()
client.join(1)
self.assertFalse(client.is_alive())
self.assertEqual(mock_wsapp.call_count, 2, "Connection has ended regularly")
def setUp(self):
self.session = Streamlink()
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