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 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