def setUp(self, load_plugins=True):
self.mocker = requests_mock.Mocker()
self.mocker.register_uri(requests_mock.ANY, requests_mock.ANY, text="")
self.mocker.start()
self.session = Streamlink()
if load_plugins:
self.session.load_plugins(self.PluginPath)
def _test_args(self, args, commandline, mock_argv, mock_popen, mock_call, mock_sleep, mock_setup_streamlink,
passthrough=False, exit_code=0):
mock_argv.__getitem__.side_effect = lambda x: args[x]
def side_effect(results):
def fn(*args):
result = results.pop(0)
return result
return fn
mock_popen.return_value = Mock(poll=Mock(side_effect=side_effect([None, 0])))
session = Streamlink()
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugin"))
actual_exit_code = 0
with patch('streamlink_cli.main.streamlink', session):
try:
streamlink_cli.main.main()
except SystemExit as exc:
actual_exit_code = exc.code
self.assertEqual(exit_code, actual_exit_code)
mock_setup_streamlink.assert_called_with()
if not passthrough:
mock_popen.assert_called_with(commandline, stderr=ANY, stdout=ANY, bufsize=ANY, stdin=ANY)
else:
mock_call.assert_called_with(commandline, stderr=ANY, stdout=ANY)
def __init__(self,
board,
target_url,
drmbypass=False,
reset=False,
verbosity=False):
self.exit = False
self.slink_exit = False
self.target_url = target_url
self.stream = None
self.stream_fd = None
self.stream_url = None
self.width = None
self.height = None
self.frame_size = None
self.stream_opened = False
self.slk = Streamlink()
self.slk.set_option('ringbuffer-size', 131072)
self.slink_running = False
self.fapp_xclbin = None
self.fapp_drmbypass = drmbypass
self.dec_process = None
self.enc_process = None
self.board = board
self.board_reset = reset
self.verb = verbosity
if board == 'aws':
self.fapp_xclbin = FPGA_BITSTREAM_AWS
elif board == 'u200':
self.fapp_xclbin = FPGA_BITSTREAM_U200
else:
raise UnknownFPGAboard(f'FPGA Board {board} not supported')
self.thread_slk = Thread(target=self.slink_read)
def init_streamlink(self):
self.session = Streamlink()
self.session.set_option("http-headers", "User-Agent=Mozilla/5.0 (Windows NT 10.0 Win64 x64 rv:72.0) Gecko/20100101 Firefox/72.0")
self.streams = self.session.streams(self.webcam)
if self.streams is None:
raise ValueError("cannot open the stream link %s" % self.webcam)
try:
qlist = list(self.streams.keys())
print(qlist)
quality = max([q for q in qlist if q[-1].lower() == 'p'])
print('The stream quality is {}'.format(quality))
self.stream = self.streams['%s' % quality]
self.stream_url = self.stream.url
self.video_cap = cv2.VideoCapture(self.stream_url)
except Exception as e:
print(e)
# raise ValueError("cannot open the stream link %s" % self.webcam)
try:
quality = 'best'
print('The stream quality is {}'.format(quality))
self.stream = self.streams['%s' % quality]
self.stream_url = self.stream.url
self.video_cap = cv2.VideoCapture(self.stream_url)
except:
try:
quality = list(self.streams.keys())[0]
print('---can not find the best stream quality, use the first one---')
print('The stream quality is {}'.format(quality))
self.stream = self.streams['%s' % quality]
self.stream_url = self.stream.url
self.video_cap = cv2.VideoCapture(self.stream_url)
except Exception as e:
print(e)
finally:
raise ValueError("cannot open the stream link %s" % self.webcam)
def test_https_proxy_set_only(self):
session = Streamlink()
session.set_option("https-proxy", "https://testhttpsproxy.com")
self.assertFalse("http" in session.http.proxies)
self.assertEqual("https://testhttpsproxy.com",
session.http.proxies['https'])
def setup_plugin_options(session: Streamlink, plugin: Type[Plugin]):
"""Sets Streamlink plugin options."""
pname = plugin.module
required = OrderedDict({})
for parg in plugin.arguments:
if parg.options.get("help") == argparse.SUPPRESS:
continue
value = getattr(
args, parg.dest if parg.is_global else parg.namespace_dest(pname))
session.set_plugin_option(pname, parg.dest, value)
if not parg.is_global:
if parg.required:
required[parg.name] = parg
# if the value is set, check to see if any of the required arguments are not set
if parg.required or value:
try:
for rparg in plugin.arguments.requires(parg.name):
required[rparg.name] = rparg
except RuntimeError:
log.error(
f"{pname} plugin has a configuration error and the arguments cannot be parsed"
)
break
if required:
for req in required.values():
if not session.get_plugin_option(pname, req.dest):
prompt = f"{req.prompt or f'Enter {pname} {req.name}'}: "
session.set_plugin_option(
pname, req.dest,
console.askpass(prompt)
if req.sensitive else console.ask(prompt))
def test(self, mock_http):
self.session = Streamlink()
self.session.load_plugins('plugins')
mock_http.get = api.HTTPSession().get
mock_http.json = api.HTTPSession().json
Resolve.bind(self.session, "test.resolve")
default_iframe = "http://mocked/default/iframe"
file_url = _stream_data["url"]
self_url = "http://mocked/live"
with requests_mock.Mocker() as mock:
mock.get(default_iframe,
text=text_with_playlist % file_url)
mock.get(file_url, text=_stream_data["text"])
mock.get(self_url, text=_website_text)
self.session.set_plugin_option("resolve",
"whitelist_netloc",
["mocked"])
plugin = Resolve(self_url)
streams = plugin._get_streams()
self.assertIn(_stream_data["name"], streams)
def get_video(self):
session = Streamlink() #创建一个会话
try:
streams = session.streams(self.movie) #在会话里输入url会返回直播的flv缓存地址
except:
try:
streams = streamlink.streams(self.movie)
except:
print('[INFO]该网站不存在plug接口')
exit(0)
print('[INFO]获取了视屏流地址.....')
list = ['source', 'medium', 'best', 'worse']
for l in list:
if streams[l].url:
print('[INFO]获得视频%s' % l)
source = streams[l].url
if 'm3u8' in str(source):
print('[ERROR]%s存在m3u8,暂不支持下载，' % l)
continue
else:
socket.setdefaulttimeout(10)
while streams[l].url:
try:
name = time.strftime('%m%d_%H%M%S',
time.localtime()) + '.flv'
print(name + '正在缓存')
path = './video/' + name
request.urlretrieve(
source, os.path.join(path)) # 'video/1.flv'
print('[INFO]您缓存的直播已下播......')
break
except socket.timeout:
continue
def __init__(self, stream_data):
# streamlink (low overhead for consecutive retreivals)
self.__session = Streamlink()
self.__url = stream_data['url']
self.__tag = stream_data['tag']
self.__frame = None
# for saving frames locally
self.__image_path = f'../images/{stream_data["image_path"]}.png'
def test_set_via_session(self):
with self._mock_console_input() as console_input:
session = Streamlink({"user-input-requester": console_input})
session.load_plugins(os.path.join(os.path.dirname(__file__), "plugins"))
p = session.resolve_url("http://test.se/channel")
self.assertEqual("username", p.input_ask("username"))
self.assertEqual("password", p.input_ask_password("password"))
def __init__(self, status_func=None):
PlayerBase.__init__(self, status_func)
self.qualities_cache = Cache(_cache_size)
self.streamlink = Streamlink()
#check if this works for multiple streams
self._output = self._create_output()
self.lock = threading.Lock()
self.alive_threads = []
def search_resolutions(self, go):
streamlink = Streamlink()
streams = streamlink.streams(f"https://www.twitch.tv/{go}")
list_resolution = [i for i in streams]
if "worst" in list_resolution:
list_resolution.remove("worst")
if "best" in list_resolution:
list_resolution.remove("best")
self.dialog_select_resolution(list_r=list_resolution)
def openStream(self):
self.safeClose(self.stream)
session = Streamlink()
if self.accessToken != "":
session.set_plugin_option('twitch', 'oauth-token',
self.accessToken)
streams = streamlink.streams("http://twitch.tv/{0}".format(
self.username))
stream = streams['best']
self.stream = stream.open()
def get_stream_url(streamer):
s = Streamlink()
url = "https://twitch.tv/" + streamer
streams = s.streams(url)
if streams == {}:
return ""
stream = streams["best"]
fd = stream.open()
stream_url = fd.writer.stream.url
fd.close()
return stream_url
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
group = parser.add_argument_group("Plugin Options").add_argument_group("UStreamTV")
session.plugins = {
'ustreamtv': UStreamTV
}
setup_plugin_args(session, parser)
group.add_argument.assert_called_with('--ustream-password', metavar="PASSWORD", help=ANY)
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {
'ustreamtv': UStreamTV
}
setup_plugin_args(session, parser)
plugin_parser.add_argument.assert_called_with('--ustream-password', metavar="PASSWORD", help=ANY)
def api(url: str):
streamlink = Streamlink()
try:
plugin = streamlink.resolve_url(url)
streams = plugin.streams()
except NoPluginError as e:
raise HTTPException(
status_code=500,
detail="Streamlink is unable to handle the URL '{0}'".format(url))
except PluginError as e:
if e.__str__().startswith('Unable to find channel'):
raise HTTPException(status_code=404, detail="Stream not found")
raise HTTPException(status_code=500,
detail="Error while fetching stream - " + str(e))
except Exception:
raise HTTPException(status_code=500,
detail="Error while fetching stream")
out = {}
for quality, stream in streams.items():
out[quality] = stream.url
live = False
if len(streams.items()) > 0:
live = True
try:
id = plugin.channel_id
except:
id = plugin.video_id
try:
channel = plugin.channel
except:
channel = None
return {
'streams': out,
'url': url,
'channel': {
'live': live,
'id': id,
'plugin': plugin.module,
'author': plugin.author,
'channel': channel,
'url': plugin.url,
'title': plugin.title
}
}
def subject(self, **params):
with requests_mock.Mocker() as mock:
mock.get("https://api.twitch.tv/kraken/users?login=foo",
json={"users": [{
"_id": 1234
}]})
mock.get(
"https://api.twitch.tv/kraken/streams/1234",
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))
return plugin._check_for_rerun()
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 subject(channel, hosts=None, disable=False):
with requests_mock.Mocker() as mock:
mock.register_uri(requests_mock.ANY,
requests_mock.ANY,
exc=requests_mock.exceptions.InvalidRequest)
if hosts is None:
mock.post("https://gql.twitch.tv/gql", json={})
else:
mock.post("https://gql.twitch.tv/gql",
response_list=[{
"json": {
"data": {
"user": {
"id": host[0],
"hosting":
None if not host[1:3] else {
"login": host[1],
"displayName": host[2]
}
}
}
}
} for host in hosts])
session = Streamlink()
Twitch.bind(session, "tests.plugins.test_twitch")
plugin = Twitch("https://twitch.tv/{0}".format(channel))
plugin.options.set("disable-hosting", disable)
res = plugin._switch_to_hosted_channel()
return res, plugin.channel, plugin.author
def setUp(self):
self.session = Streamlink()
self.session.http = MagicMock(HTTPSession)
self.session.http.headers = {}
Generic.bind(self.session, "test.generic")
self.res_plugin = Generic("generic://https://example.com")
self.res_plugin.html_text = ''
def startRecording(model):
# 处理队列
#global processingQueue
# try:
result = requests.get(
'https://chaturbate.com/api/chatvideocontext/{}/'.format(
model)).json()
session = Streamlink()
session.set_option('http-headers',
"referer=https://www.chaturbate.com/{}".format(model))
ts = "hlsvariant://{}".format(result['hls_source'].rsplit('?')[0])
print(ts)
streams = session.streams(ts)
stream = streams["best"]
fd = stream.open()
def subject(self, channel, hosts=None, disable=False):
with requests_mock.Mocker() as mock:
mock.get("https://api.twitch.tv/kraken/users?login=foo",
json={"users": [{
"_id": 1
}]})
if hosts is None:
mock.get("https://tmi.twitch.tv/hosts", json={})
else:
mock.get("https://tmi.twitch.tv/hosts", [{
"json": {
"hosts": [
dict(host_id=host_id,
target_id=target_id,
target_login=target_login,
target_display_name=target_display_name)
]
}
} for host_id, target_id, target_login, target_display_name in
hosts])
session = Streamlink()
Twitch.bind(session, "tests.plugins.test_twitch")
plugin = Twitch("https://twitch.tv/{0}".format(channel))
plugin.options.set("disable-hosting", disable)
res = plugin._switch_to_hosted_channel()
return res, plugin.channel, plugin._channel_id, plugin.author
def __new__(mcs, name, bases, dict):
plugin_path = os.path.dirname(streamlink.plugins.__file__)
plugins = []
for loader, pname, ispkg in pkgutil.iter_modules([plugin_path]):
module = load_module(pname, plugin_path)
if hasattr(module, "__plugin__"):
plugins.append((pname))
session = Streamlink()
def gentest(pname):
def load_plugin_test(self):
# Reset file variable to ensure it is still open when doing
# load_plugin else python might open the plugin source .py
# using ascii encoding instead of utf-8.
# See also open() call here: imp._HackedGetData.get_data
file, pathname, desc = imp.find_module(pname, [plugin_path])
session.load_plugin(pname, file, pathname, desc)
# validate that can_handle_url does not fail
session.plugins[pname].can_handle_url("http://test.com")
return load_plugin_test
for pname in plugins:
dict['test_{0}_load'.format(pname)] = gentest(pname)
return type.__new__(mcs, name, bases, dict)
def setUpClass(cls):
cls.session = Streamlink()
docs_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "../docs"))
plugins_dir = streamlinkplugins.__path__[0]
with open(os.path.join(docs_dir, "plugin_matrix.rst")) as plfh:
parts = re.split(r"\n[= ]+\n", plfh.read())
cls.plugins_in_docs = list(
re.findall(r"^([\w_]+)\s", parts[3], re.MULTILINE))
with open(os.path.join(plugins_dir, ".removed")) as rmfh:
cls.plugins_removed = [
pname for pname in rmfh.read().split("\n")
if pname and not pname.startswith("#")
]
tests_plugins_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "plugins"))
tests_plugin_files = glob(os.path.join(tests_plugins_dir, "test_*.py"))
cls.plugins = cls.session.plugins.keys()
cls.plugin_tests = [
re.sub(r"^test_(.+)\.py$", r"\1", os.path.basename(file))
for file in tests_plugin_files
]
cls.plugins_no_protocols = [
pname for pname in cls.plugins if pname not in cls.protocol_tests
]
cls.plugin_tests_no_protocols = [
pname for pname in cls.plugin_tests
if pname not in cls.protocol_tests
]
def setUp(self):
self.session = Streamlink()
docs_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "../docs"))
with open(os.path.join(docs_dir, "plugin_matrix.rst")) as plfh:
parts = self.title_re.split(plfh.read())
self.plugins_in_docs = list(self.plugin_re.findall(parts[3]))
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {
'tvplayer': TVPlayer
}
setup_plugin_args(session, parser)
self.assertSequenceEqual(plugin_parser.add_argument.mock_calls,
[call('--tvplayer-email', metavar="EMAIL", help=ANY),
call('--tvplayer-password', metavar="PASSWORD", help=ANY)],
)
def session():
session = Streamlink()
session.set_option("http-cookies",
{"sessioncookiekey": "sessioncookieval"})
session.set_option("http-headers",
{"sessionheaderkey": "sessionheaderval"})
session.set_option("http-query-params",
{"sessionqueryparamkey": "sessionqueryparamval"})
return session
class viewThread(threading.Thread):
streamlink = Streamlink()
fd = None
run_v = False
fileHandle = None
def __init__(self, channel, quality):
threading.Thread.__init__(self)
self.channel = channel
self.quality = quality
# Create the Streamlink session
url = "http://twitch.tv/"
url += channel[1:]
# print "url"+url
try:
self.streamlink.set_option("http-proxy", http_proxy)
# self.streamlink.set_option("https-proxy", http_proxy)
self.streamlink.set_option("rtmp-proxy", http_proxy)
streams = self.streamlink.streams(url)
except NoPluginError:
exit("Streamlink is unable to handle the URL '{0}'".format(url))
except PluginError as err:
exit("Plugin error: {0}".format(err))
# Look for specified stream
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(
quality, url))
# We found the stream
stream = streams[quality]
self.fd = stream.open()
#
#open fil
self.fileHandle = open('videodump.flv', 'w')
def run(self):
print "Starting recording"
self.run_v = True
# Get lock to synchronize threads
while self.run_v:
try:
if self.fd:
data = self.fd.read(1024)
self.fileHandle.write(data)
except KeyboardInterrupt:
print "Ctrl-c pressed ..."
self.run_v = False
def stop(self):
self.run_v = False
if self.fd:
self.fd.close()
if self.fileHandle:
self.fileHandle.close()
def extract_stream(stream_url):
"""extracts the stream url from the encrypted url"""
url = stream_url[0]
print "Attempting to extract {0}".format(url)
# Create the Streamlink session
streamlink = Streamlink()
#stream quality
quality = "best"
# Enable logging
streamlink.set_loglevel("info")
streamlink.set_logoutput(sys.stdout)
# Attempt to fetch streams
try:
streams = streamlink.streams(url)
except NoPluginError:
exit("Streamlink is unable to handle the URL '{0}'".format(url))
except PluginError as err:
exit("Plugin error: {0}".format(err))
if not streams:
exit("No streams found on URL '{0}'".format(url))
# Look for specified stream
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url))
# We found the stream
stream = streams[quality]
return stream.url
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {
'funimationnow': FunimationNow
}
setup_plugin_args(session, parser)
self.assertSequenceEqual(plugin_parser.add_argument.mock_calls,
[call('--funimation-language',
choices=["en", "ja", "english", "japanese"],
default="english", help=ANY),
call('--funimation-mux-subtitles', action="store_true", help=ANY)])
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {'funimationnow': FunimationNow}
setup_plugin_args(session, parser)
self.assertSequenceEqual(plugin_parser.add_argument.mock_calls, [
call('--funimation-language',
choices=["en", "ja", "english", "japanese"],
default="english",
help=ANY),
call('--funimation-mux-subtitles', action="store_true", help=ANY)
])
def test_arguments(self):
from streamlink_cli.main import setup_plugin_args
session = Streamlink()
parser = MagicMock()
plugin_parser = MagicMock()
parser.add_argument_group = MagicMock(return_value=plugin_parser)
session.plugins = {'tvplayer': TVPlayer}
setup_plugin_args(session, parser)
self.assertSequenceEqual(
plugin_parser.add_argument.mock_calls,
[
call('--tvplayer-email', metavar="EMAIL", help=ANY),
call('--tvplayer-password', metavar="PASSWORD", help=ANY)
],
)
class TestPluginStream(unittest.TestCase):
def setUp(self):
self.session = Streamlink()
def assertDictHas(self, a, b):
for key, value in a.items():
self.assertEqual(b[key], value)
def _test_akamaihd(self, surl, url):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, AkamaiHDStream))
self.assertEqual(stream.url, url)
@patch('streamlink.stream.HLSStream.parse_variant_playlist')
def _test_hls(self, surl, url, mock_parse):
mock_parse.return_value = {}
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
mock_parse.assert_called_with(self.session, url)
stream = streams["live"]
self.assertTrue(isinstance(stream, HLSStream))
self.assertEqual(stream.url, url)
@patch('streamlink.stream.HLSStream.parse_variant_playlist')
def _test_hlsvariant(self, surl, url, mock_parse):
mock_parse.return_value = {"best": HLSStream(self.session, url)}
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
mock_parse.assert_called_with(self.session, url)
self.assertFalse("live" in streams)
self.assertTrue("best" in streams)
stream = streams["best"]
self.assertTrue(isinstance(stream, HLSStream))
self.assertEqual(stream.url, url)
def _test_rtmp(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, RTMPStream))
self.assertEqual(stream.params["rtmp"], url)
self.assertDictHas(params, stream.params)
def _test_http(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, HTTPStream))
self.assertEqual(stream.url, url)
self.assertDictHas(params, stream.args)
def test_plugin_rtmp(self):
self._test_rtmp("rtmp://hostname.se/stream",
"rtmp://hostname.se/stream", dict())
self._test_rtmp("rtmp://hostname.se/stream live=1 qarg='a \\'string' noq=test",
"rtmp://hostname.se/stream", dict(live=True, qarg='a \'string', noq="test"))
self._test_rtmp("rtmp://hostname.se/stream live=1 num=47",
"rtmp://hostname.se/stream", dict(live=True, num=47))
self._test_rtmp("rtmp://hostname.se/stream conn=['B:1','S:authMe','O:1','NN:code:1.23','NS:flag:ok','O:0']",
"rtmp://hostname.se/stream",
dict(conn=['B:1', 'S:authMe', 'O:1', 'NN:code:1.23', 'NS:flag:ok', 'O:0']))
def test_plugin_hls(self):
self._test_hls("hls://https://hostname.se/playlist.m3u8",
"https://hostname.se/playlist.m3u8")
self._test_hls("hls://hostname.se/playlist.m3u8",
"http://hostname.se/playlist.m3u8")
self._test_hlsvariant("hls://hostname.se/playlist.m3u8",
"http://hostname.se/playlist.m3u8")
self._test_hlsvariant("hls://https://hostname.se/playlist.m3u8",
"https://hostname.se/playlist.m3u8")
def test_plugin_akamaihd(self):
self._test_akamaihd("akamaihd://http://hostname.se/stream",
"http://hostname.se/stream")
self._test_akamaihd("akamaihd://hostname.se/stream",
"http://hostname.se/stream")
def test_plugin_http(self):
self._test_http("httpstream://http://hostname.se/auth.php auth=('test','test2')",
"http://hostname.se/auth.php", dict(auth=("test", "test2")))
self._test_http("httpstream://hostname.se/auth.php auth=('test','test2')",
"http://hostname.se/auth.php", dict(auth=("test", "test2")))
self._test_http("httpstream://https://hostname.se/auth.php verify=False params={'key': 'a value'}",
"https://hostname.se/auth.php?key=a+value", dict(verify=False, params=dict(key='a value')))
def test_parse_params(self):
self.assertEqual(
dict(verify=False, params=dict(key="a value")),
parse_params("""verify=False params={'key': 'a value'}""")
)
self.assertEqual(
dict(verify=False),
parse_params("""verify=False""")
)
self.assertEqual(
dict(conn=['B:1', 'S:authMe', 'O:1', 'NN:code:1.23', 'NS:flag:ok', 'O:0']),
parse_params(""""conn=['B:1', 'S:authMe', 'O:1', 'NN:code:1.23', 'NS:flag:ok', 'O:0']""")
)
def test_stream_weight(self):
self.assertEqual(
(720, "pixels"),
stream_weight("720p"))
self.assertEqual(
(721, "pixels"),
stream_weight("720p+"))
self.assertEqual(
(780, "pixels"),
stream_weight("720p60"))
self.assertTrue(
stream_weight("720p+") > stream_weight("720p"))
self.assertTrue(
stream_weight("720p") == stream_weight("720p"))
self.assertTrue(
stream_weight("720p_3000k") > stream_weight("720p_2500k"))
self.assertTrue(
stream_weight("720p60_3000k") > stream_weight("720p_3000k"))
self.assertTrue(
stream_weight("720p_3000k") < stream_weight("720p+_3000k"))
self.assertTrue(
stream_weight("3000k") > stream_weight("2500k"))
def setUp(self):
self.session = Streamlink()
self.session.load_plugins(self.PluginPath)
def setUp(self):
self.session = Streamlink()
def get_session():
s = Streamlink()
s.load_plugins(PluginPath)
return s
class TestSession(unittest.TestCase):
PluginPath = os.path.join(os.path.dirname(__file__), "plugins")
def setUp(self):
self.session = Streamlink()
self.session.load_plugins(self.PluginPath)
def test_exceptions(self):
try:
self.session.resolve_url("invalid url")
self.assertTrue(False)
except NoPluginError:
self.assertTrue(True)
def test_load_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue(plugins["testplugin"])
def test_builtin_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue("twitch" in plugins)
def test_resolve_url(self):
plugins = self.session.get_plugins()
channel = self.session.resolve_url("http://test.se/channel")
self.assertTrue(isinstance(channel, Plugin))
self.assertTrue(isinstance(channel, plugins["testplugin"]))
def test_resolve_url_priority(self):
from tests.plugins.testplugin import TestPlugin
class HighPriority(TestPlugin):
@classmethod
def priority(cls, url):
return HIGH_PRIORITY
class LowPriority(TestPlugin):
@classmethod
def priority(cls, url):
return LOW_PRIORITY
self.session.plugins = {
"test_plugin": TestPlugin,
"test_plugin_low": LowPriority,
"test_plugin_high": HighPriority,
}
channel = self.session.resolve_url_no_redirect("http://test.se/channel")
plugins = self.session.get_plugins()
self.assertTrue(isinstance(channel, plugins["test_plugin_high"]))
self.assertEqual(HIGH_PRIORITY, channel.priority(channel.url))
def test_resolve_url_no_redirect(self):
plugins = self.session.get_plugins()
channel = self.session.resolve_url_no_redirect("http://test.se/channel")
self.assertTrue(isinstance(channel, Plugin))
self.assertTrue(isinstance(channel, plugins["testplugin"]))
def test_options(self):
self.session.set_option("test_option", "option")
self.assertEqual(self.session.get_option("test_option"), "option")
self.assertEqual(self.session.get_option("non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "a_option"), "default")
self.session.set_plugin_option("testplugin", "another_option", "test")
self.assertEqual(self.session.get_plugin_option("testplugin", "another_option"), "test")
self.assertEqual(self.session.get_plugin_option("non_existing", "non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "non_existing"), None)
def test_plugin(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams()
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1080p"])
self.assertTrue(streams["worst"] is streams["350k"])
self.assertTrue(isinstance(streams["rtmp"], RTMPStream))
self.assertTrue(isinstance(streams["http"], HTTPStream))
self.assertTrue(isinstance(streams["hls"], HLSStream))
self.assertTrue(isinstance(streams["akamaihd"], AkamaiHDStream))
def test_plugin_stream_types(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(stream_types=["http", "rtmp"])
self.assertTrue(isinstance(streams["480p"], HTTPStream))
self.assertTrue(isinstance(streams["480p_rtmp"], RTMPStream))
streams = channel.get_streams(stream_types=["rtmp", "http"])
self.assertTrue(isinstance(streams["480p"], RTMPStream))
self.assertTrue(isinstance(streams["480p_http"], HTTPStream))
def test_plugin_stream_sorted_excludes(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(sorting_excludes=["1080p", "3000k"])
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1500k"])
streams = channel.get_streams(sorting_excludes=[">=1080p", ">1500k"])
self.assertTrue(streams["best"] is streams["1500k"])
streams = channel.get_streams(sorting_excludes=lambda q: not q.endswith("p"))
self.assertTrue(streams["best"] is streams["3000k"])
def test_plugin_support(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams()
self.assertTrue("support" in streams)
self.assertTrue(isinstance(streams["support"], HTTPStream))
