def on_start(self): proxy = httpclient.format_proxy(self.config["proxy"]) youtube.Video.proxy = proxy headers = { "user-agent": httpclient.format_user_agent(self.user_agent), "Cookie": "PREF=hl=en;", "Accept-Language": "en;q=0.8", } if youtube.api_enabled is True: if youtube_api.youtube_api_key is None: logger.error("No YouTube API key provided, disabling API") youtube.api_enabled = False else: youtube.Entry.api = youtube_api.API(proxy, headers) if youtube.Entry.search(q="test") is None: logger.error( "Failed to verify YouTube API key, disabling API" ) youtube.api_enabled = False else: logger.info("YouTube API key verified") if youtube.api_enabled is False: # regex based api # logger.info("Using scrAPI") # youtube.Entry.api = youtube_scrapi.scrAPI(proxy, headers) # # beautiful soup 4 based api logger.info("using bs4API") youtube.Entry.api = youtube_bs4api.bs4API(proxy, headers)
def on_start(self): proxy = httpclient.format_proxy(self.config['proxy']) youtube.Video.proxy = proxy headers = { 'user-agent': httpclient.format_user_agent(self.user_agent), 'Cookie': 'PREF=hl=en;', 'Accept-Language': 'en;q=0.8' } if youtube.api_enabled is True: if youtube.API.youtube_api_key is None: logger.error('No YouTube API key provided, disabling API') youtube.api_enabled = False else: youtube.Entry.api = youtube.API(proxy, headers) if youtube.Entry.search(q='test') is None: logger.error( 'Failed to verify YouTube API key, disabling API') youtube.api_enabled = False else: logger.info('YouTube API key verified') if youtube.api_enabled is False: logger.info('Using scrAPI') youtube.Entry.api = youtube.scrAPI(proxy, headers)
def __init__(self, config, audio): super(RNZBackend, self).__init__() self.library = RNZLibraryProvider(backend=self) self.uri_schemes = ['rnz'] http_cache = config['rnz']['http_cache'] http_cache = os.path.expanduser(http_cache) logging.info("http_cache: %s", http_cache) requests_cache.install_cache(http_cache, backend='sqlite', expire_after=300) proxy_config = config['proxy'] self.session = requests.Session() if proxy_config is not None: proxy = httpclient.format_proxy(proxy_config) self.session.proxies.update({'http': proxy, 'https': proxy}) full_user_agent = httpclient.format_user_agent( "%s/%s" % (mopidy_rnz.Extension.dist_name, mopidy_rnz.__version__)) logging.debug('user_agent: %s', full_user_agent) self.session.headers.update({'user-agent': full_user_agent})
def __init__(self, config): self.proxy = httpclient.format_proxy(config["proxy"]) self.ua_str = httpclient.format_user_agent( f"{mopidy_bandcamp.Extension.dist_name}/{mopidy_bandcamp.__version__}" ) self.identity = config["bandcamp"]["identity"] self.collection_items = config["bandcamp"]["collection_items"] self.fan_id = None
def _get_session(self, proxy_config): proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent('/'.join(( mopidy_beets.BeetsExtension.dist_name, mopidy_beets.__version__))) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def _get_session(self, proxy_config): proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent('/'.join( (mopidy_beets.BeetsExtension.dist_name, mopidy_beets.__version__))) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def get_requests_session(proxy_config, user_agent): proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def get_requests_session(proxy_config, user_agent, token): proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({"http": proxy, "https": proxy}) session.headers.update({"user-agent": full_user_agent}) return session
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.last_id = None self.Youtube_Player_URL = None self.YoutubeDL = YoutubeDL({ "proxy": httpclient.format_proxy(self.backend.config["proxy"]), "nocheckcertificate": True, }) self.YoutubeIE = self.YoutubeDL.get_info_extractor('Youtube')
def get_requests_session(proxy_config): user_agent = '%s/%s' % (Extension.dist_name, __version__) proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def get_requests_session(self): proxy = httpclient.format_proxy(self.__config['proxy']) full_user_agent = httpclient.format_user_agent( '%s/%s' % (self.__dist_name, self.__version)) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def get_requests_session(proxy_config): user_agent = f"{Extension.dist_name}/{__version__}" proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({"http": proxy, "https": proxy}) session.headers.update({"user-agent": full_user_agent}) return session
def get_requests_session(cls, config): import requests proxy = httpclient.format_proxy(config['proxy']) user_agent_string = '%s/%s' % (cls.dist_name, cls.version) user_agent = httpclient.format_user_agent(user_agent_string) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': user_agent}) return session
def get_requests_session(proxy_config, user_agent, token, public=False): proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({"http": proxy, "https": proxy}) if not public: session.headers.update({"user-agent": full_user_agent}) session.headers.update({"Authorization": f"OAuth {token}"}) return session
def get_requests_session(proxy_config, user_agent): logger.debug('RadioBrowser: Start backend.get_requests_session') proxy = httpclient.format_proxy(proxy_config) full_user_agent = httpclient.format_user_agent(user_agent) session = requests.Session() session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def __init__(self, audio, backend, proxy_config=None, user_agent=None): super().__init__(audio=audio, backend=backend) # Build requests session self.session = requests.Session() if proxy_config is not None: proxy = httpclient.format_proxy(proxy_config) self.session.proxies.update({"http": proxy, "https": proxy}) full_user_agent = httpclient.format_user_agent(user_agent) self.session.headers.update({"user-agent": full_user_agent})
def _get_session(self): proxy = httpclient.format_proxy(self.proxy) full_user_agent = httpclient.format_user_agent('/'.join( (mopidy_emby.Extension.dist_name, mopidy_emby.__version__))) session = requests.Session() session.cert = self.cert session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': full_user_agent}) return session
def __init__(self, proxy_config=None, user_agent=None): super(SomaFMClient, self).__init__() # Build requests session self.session = requests.Session() if proxy_config is not None: proxy = httpclient.format_proxy(proxy_config) self.session.proxies.update({'http': proxy, 'https': proxy}) full_user_agent = httpclient.format_user_agent(user_agent) self.session.headers.update({'user-agent': full_user_agent})
def __init__(self, proxy_config=None, user_agent=None): super(RadioNetClient, self).__init__() self.session = requests.Session() if proxy_config is not None: proxy = httpclient.format_proxy(proxy_config) self.session.proxies.update({'http': proxy, 'https': proxy}) full_user_agent = httpclient.format_user_agent(user_agent) self.session.headers.update({'user-agent': full_user_agent}) self.session.headers.update({'cache-control': 'no-cache'})
def __init__(self, headers, cert=None, proxy=None): http_proxy = httpclient.format_proxy(proxy) user_agent = httpclient.format_user_agent('/'.join( (mopidy_jellyfin.Extension.dist_name, mopidy_jellyfin.__version__))) self.headers = headers self.session = requests.Session() self.session.cert = cert self.session.proxies.update({'http': http_proxy, 'https': http_proxy}) self.session.headers.update(self.headers) self.session.headers.update({'user-agent': user_agent})
def get_url_opener(cls, config): import urllib2 proxy = httpclient.format_proxy(config['proxy']) if proxy: handlers = [urllib2.ProxyHandler({'http': proxy, 'https': proxy})] else: handlers = [] opener = urllib2.build_opener(*handlers) user_agent = '%s/%s' % (cls.dist_name, cls.version) opener.addheaders = [('User-agent', httpclient.format_user_agent(user_agent))] return opener
def get_url_opener(cls, config): import urllib2 proxy = httpclient.format_proxy(config['proxy']) if proxy: handlers = [urllib2.ProxyHandler({'http': proxy, 'https': proxy})] else: handlers = [] opener = urllib2.build_opener(*handlers) user_agent = '%s/%s' % (cls.dist_name, cls.version) opener.addheaders = [ ('User-agent', httpclient.format_user_agent(user_agent)) ] return opener
def setup_proxy(element, config): """Configure a GStreamer element with proxy settings. :param element: element to setup proxy in. :type element: :class:`Gst.GstElement` :param config: proxy settings to use. :type config: :class:`dict` """ if not hasattr(element.props, "proxy") or not config.get("hostname"): return element.set_property("proxy", httpclient.format_proxy(config, auth=False)) element.set_property("proxy-id", config.get("username")) element.set_property("proxy-pw", config.get("password"))
def make_session(config): proxy = httpclient.format_proxy(config['proxy']) agent = httpclient.format_user_agent('%s/%s' % ( mopidy_funkwhale.Extension.dist_name, mopidy_funkwhale.__version__)) funkwhale_config = config['funkwhale'] url = urlparse.urljoin(funkwhale_config['host'], '/api/v1/') session = SessionWithUrlBase(url_base=url) session.proxies.update({'http': proxy, 'https': proxy}) session.headers.update({'user-agent': agent}) return session
def __init__( self, hostname: str, port: int, proxy_config: Dict[str, str], user_agent: str, ): self.cache_location: Path = self._init_cache_location() self.hostname: str = hostname self.port: int = port self.http_session: requests.Session = self._init_http_session( proxy=httpclient.format_proxy(proxy_config), user_agent=httpclient.format_user_agent(user_agent), )
def setup_proxy(element, config): """Configure a GStreamer element with proxy settings. :param element: element to setup proxy in. :type element: :class:`gst.GstElement` :param config: proxy settings to use. :type config: :class:`dict` """ if not hasattr(element.props, 'proxy') or not config.get('hostname'): return element.set_property('proxy', httpclient.format_proxy(config, auth=False)) element.set_property('proxy-id', config.get('username')) element.set_property('proxy-pw', config.get('password'))
def __init__(self, proxy, username, password): self._session = requests.Session() self._username = username self._password = password self._login_result = None proxy_formatted = httpclient.format_proxy(proxy) if proxy_formatted: self._session.proxies.update({ 'http': proxy_formatted, 'https': proxy_formatted }) self._session.verify = False self._download_server_address = '' self._download_url_footer = ''
def __init__(self, config, audio): super(InternetArchiveBackend, self).__init__() ext_config = config[Extension.ext_name] self.client = client = InternetArchiveClient( ext_config['base_url'], retries=ext_config['retries'], timeout=ext_config['timeout'] ) product = '%s/%s' % (Extension.dist_name, Extension.version) client.useragent = httpclient.format_user_agent(product) proxy = httpclient.format_proxy(config['proxy']) client.proxies.update({'http': proxy, 'https': proxy}) client.cache = _cache(**ext_config) self.library = InternetArchiveLibraryProvider(ext_config, self) self.playback = InternetArchivePlaybackProvider(audio, self)
def __init__(self, config, audio): super().__init__() ext_config = config[Extension.ext_name] self.client = client = InternetArchiveClient( ext_config["base_url"], retries=ext_config["retries"], timeout=ext_config["timeout"], ) product = f"{Extension.dist_name}/{Extension.version}" client.useragent = httpclient.format_user_agent(product) proxy = httpclient.format_proxy(config["proxy"]) client.proxies.update({"http": proxy, "https": proxy}) client.cache = _cache(**ext_config) self.library = InternetArchiveLibraryProvider(ext_config, self) self.playback = InternetArchivePlaybackProvider(audio, self)
def __init__(self, config, audio): super().__init__() self.config = config self.audio = audio self.uri_schemes = ["ytm"] from youtube_dl import YoutubeDL from ytmusicapi.ytmusic import YTMusic global YDL YDL = YoutubeDL({ "format": "bestaudio/m4a/mp3/ogg/best", "proxy": httpclient.format_proxy(self.config["proxy"]), "nocheckcertificate": True, "cachedir": False, }) global API API = YTMusic(config["ytmusic"]["auth_json"]) self.playback = YouTubePlaybackProvider(audio=audio, backend=self) self.library = YouTubeLibraryProvider(backend=self) self.playlists = YouTubePlaylistsProvider(backend=self)
def _get_spotify_config(self, config): ext = Extension() spotify_config = spotify.Config() spotify_config.load_application_key_file( pathlib.Path(__file__).parent / "spotify_appkey.key") if config["spotify"]["allow_cache"]: spotify_config.cache_location = bytes(ext.get_cache_dir(config)) else: spotify_config.cache_location = None spotify_config.settings_location = bytes(ext.get_data_dir(config)) proxy_uri = httpclient.format_proxy(config["proxy"], auth=False) if proxy_uri is not None: logger.debug(f"Connecting to Spotify through proxy: {proxy_uri}") spotify_config.proxy = proxy_uri spotify_config.proxy_username = config["proxy"].get("username") spotify_config.proxy_password = config["proxy"].get("password") return spotify_config
def _get_spotify_config(self, config): ext = Extension() spotify_config = spotify.Config() spotify_config.load_application_key_file( os.path.join(os.path.dirname(__file__), 'spotify_appkey.key')) if config['spotify']['allow_cache']: spotify_config.cache_location = ext.get_cache_dir(config) else: spotify_config.cache_location = None spotify_config.settings_location = ext.get_data_dir(config) proxy_uri = httpclient.format_proxy(config['proxy'], auth=False) if proxy_uri is not None: logger.debug('Connecting to Spotify through proxy: %s', proxy_uri) spotify_config.proxy = proxy_uri spotify_config.proxy_username = config['proxy'].get('username') spotify_config.proxy_password = config['proxy'].get('password') return spotify_config
def __init__(self, backend): self._config = backend._config['spotify_tunigo'] proxy = httpclient.format_proxy(backend._config['proxy']) self._tunigo = Tunigo( region=self._config['region'], cache_time=self._config['cache_time'], proxies={'http': proxy, 'https': proxy}) self._root = [ Ref.directory( uri='spotifytunigo:featured', name='Featured Playlists'), Ref.directory( uri='spotifytunigo:toplists', name='Top Lists'), Ref.directory( uri='spotifytunigo:genres', name='Genres & Moods'), Ref.directory( uri='spotifytunigo:releases', name='New Releases')]
def get_proxy(cfg): return format_proxy(cfg['proxy'])
def test_format_proxy_without_auth(): config = {'username': '******', 'password': '******', 'hostname': 'proxy.lan'} formated_proxy = httpclient.format_proxy(config, auth=False) assert formated_proxy == 'http://proxy.lan:80'
def test_format_proxy(config, expected): assert httpclient.format_proxy(config) == expected