def __init__(self, serverHandler, username=None, password=None): self.serverHandler = serverHandler hdlr = logging.FileHandler(expanduser("~") + '/hapi.log') formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') hdlr.setFormatter(formatter) self.logger.addHandler(hdlr) self.logger.setLevel(logging.INFO) self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.logger.info('Initializing player') self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) try: self.audio_driver = spotify.AlsaSink(self.session) except ImportError: self.logger.warning( 'No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start() if username is not None and password is not None: self.login(username, password) self.logger.info('Ready') self.currentTrack = None
def account_login(self, source, username, passwd): if source == 'spotify': if self.session.connection.state is spotify.ConnectionState.LOGGED_IN: return # Process events in the background loop = spotify.EventLoop(self.session) loop.start() # Connect an audio sink try: audio = spotify.PortAudioSink(self.session) except: audio = spotify.AlsaSink(self.session) # Events for coordination self.logged_in = threading.Event() self.end_of_track = threading.Event() # Register event listeners self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_updated) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.session.login(username, passwd) # Wait until flag is set true self.logged_in.wait() print self.session.user # self.session.inbox.load() logger.info("User %s successfully logged in.", self.session.user) self.logged_in.wait()
def __init__(self): self.logger = logging.getLogger(__name__) self.session = spotify.Session() self.loop = spotify.EventLoop(self.session) self.audio = spotify.PortAudioSink(self.session) self.current_state = SpotifyService.STOPPED self.loop.start()
def login(self): # Assuming a spotify_appkey.key in the current dir self.session = spotify.Session() # Process events in the background self._loop = spotify.EventLoop(self.session) self._loop.start() # Connect an audio sink if sys.platform == "darwin": audio = spotify.PortAudioSink(self.session) else: audio = spotify.AlsaSink(self.session) # Register event listeners self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self._on_connection_state_updated) self.session.on(spotify.SessionEvent.END_OF_TRACK, self._on_end_of_track) # Assuming a previous login with remember_me=True and a proper logout if self._settings.SPOTIFY_USERNAME == None or self._settings.SPOTIFY_PASSWORD == None: raise StandardError("No username/password") self.session.login(self._settings.SPOTIFY_USERNAME, self._settings.SPOTIFY_PASSWORD) self._logged_in.wait() return self.session
def __init__(self, controller): self._controller = controller self.current_track = None self.current_track_uri = None self.is_playing = False # spotify player instance variables self.logged_in_event = threading.Event() self.end_of_track_event = threading.Event() # spotify API config & login config = spotify.Config() keypath = sys.path[0]+"/spotify_appkey.key" config.load_application_key_file(filename=keypath) self.session = spotify.Session(config) self.session.login(SPOTIFY_AUTH['username'], SPOTIFY_AUTH['password']) # define audio sink spotify.AlsaSink(self.session, JUKEBIKE_CONF['PCM_ID']) # start event loop thread, which automatically processes events from lip event_loop = spotify.EventLoop(self.session) event_loop.start() # register listener for login, end of track / ... self.session.on(spotify.SessionEvent.LOGGED_IN, self.connection_state_listener) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.track_state_listener) # is being called endlessly when track ends # TODO to be implemented, if necessary #CONNECTION_ERROR #MESSAGE_TO_USER # wait for login to succeed self.logged_in_event.wait()
def __init__(self): self.playlist = None self.track = None # Track selected either by the user or the playlist to be played next self.curplaytrack = None # Currently playing track self.selindex = None # Index of self.track within self.playlist print('Start logging in') logged_in_event = threading.Event() def connection_state_listener(session, error_type): if error_type is spotify.ErrorType.OK: logged_in_event.set() else: print('Spotify authentication failed, please check login credentials') print('Program terminating') quit() self.session = spotify.Session(self.configsession()) self.audio = spotify.AlsaSink(self.session) loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.LOGGED_IN, connection_state_listener) from secrets import username from secrets import password self.session.login(username, password) # Blocks the thread until the log in operation completes logged_in_event.wait() print('Logged in as', username) # Set up listener for when the currently playing track finishes self.session.on(spotify.SessionEvent.END_OF_TRACK, self.next)
def __init__(self, args): threading.Thread.__init__(self) # set to a daemon thread self.daemon = True self.args = args self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.session = spotify.Session() bit_rates = dict([('160', BitRate.BITRATE_160K), ('320', BitRate.BITRATE_320K), ('96', BitRate.BITRATE_96K)]) self.session.preferred_bitrate(bit_rates[args.bitrate]) self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.session.on(spotify.SessionEvent.MUSIC_DELIVERY, self.on_music_delivery) self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def __init__(self, session, ui): self.session = session self.ui = ui self.audio = spotify.AlsaSink(session) self.loop = spotify.EventLoop(session) self.loop.start() self.p_thread = player_thread.PlayerThread(self, self.session) self.p_thread.start()
def on_start(self): self._actor_proxy = self.actor_ref.proxy() self._session = self._get_session(self._config) self._event_loop = spotify.EventLoop(self._session) self._event_loop.start() self._session.login(self._config['spotify']['username'], self._config['spotify']['password'])
def play(command): loop = spotify.EventLoop(session) loop.start() # Connect an audio sink audio = spotify.AlsaSink(session) # Events for coordination logged_in = threading.Event() end_of_track = threading.Event() def on_connection_state_updated(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in.set() def on_end_of_track(self): end_of_track.set() # Register event listeners session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, on_connection_state_updated) session.on(spotify.SessionEvent.END_OF_TRACK, on_end_of_track) # Assuming a previous login with remember_me=True and a proper logout session.relogin() logged_in.wait() commandl = command.split(" ") triggers = ['spotify', 'play'] triggerword = None for word in commandl: for trigger in triggers: if word.lower() == trigger: triggerword = word else: pass if triggerword == None: return "trigger word not found" else: searchterm = command.split(triggerword) search = session.search(searchterm) search = session.search(searchterm, search_type=spotify.SearchType.SUGGEST).load() playitem = None if len(search.tracks) > 0: playitem = search.tracks[0] track = session.get_track(track_uri).load() session.player.load(track) session.player.play() # Wait for playback to complete or Ctrl+C try: while not end_of_track.wait(0.1): pass except KeyboardInterrupt: pass
def __init__(self): self._session = spotify.Session() self._session.volume_normalization = True self._loop = spotify.EventLoop(self._session) self._audio = get_config().audio_class(self._session) self._track_repository = service_registry.get("track_repository") self._current_track_notifier = service_registry.get("current_track_notifier") self._current_track = None self._plugins = self.register_plugins()
def __init__(self): self.googleapi = Mobileclient() config = spotify.Config() config.cache_location = "tmp" config.load_application_key_file(SPOTIFY_APPKEY) self.spotify_session = spotify.Session(config) self.loop = spotify.EventLoop(self.spotify_session) self.logged_in_event = threading.Event() self._google_loggedin = False
def main(args): if args.verbose: logging.basicConfig(level=logging.DEBUG) session = spotify.Session() loop = spotify.EventLoop(session) loop.start() login(session, args.username, args.password) try: if args.command == 'info': session.playlist_container.load() result = { 'success': True, 'action': args.command, 'response': { 'user_name': session.user_name, 'num_playlists': len(session.playlist_container), 'num_starred': len(session.starred.tracks), }, } elif args.command == 'create-playlist': name, uri = create_playlist(session, args.name) result = { 'success': True, 'action': args.command, 'response': { 'playlist_name': name, 'playlist_uri': uri, }, } elif args.command == 'add-track': playlist_uri, track_uri = add_track(session, args.playlist, args.track) result = { 'success': True, 'action': args.command, 'response': { 'playlist_uri': playlist_uri, 'track_uri': track_uri, }, } except spotify.Error as error: logger.exception('%s failed', args.command) result = { 'success': False, 'action': args.command, 'error': str(error), } # Proper logout ensures that all data is persisted properly logout(session) return result
def __init__(self, config_file): with open(config_file, 'r') as fh: self.config = yaml.load(fh) self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.connection_state_listener) self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.logged_in = threading.Event()
def __init__ (self): self.session = spotify.Session() self.validLogin = False self.name = '' self.searchResults = False self.logged_in_event = threading.Event() #USeful fr login CHeck self.TopArtists = [] self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.loop.start() self.end_of_track = threading.Event()
def __init__(self): cmd.Cmd.__init__(self) self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.session = spotify.Session() self.session.on(spotify.SessionEvent.LOGGED_IN, self.on_logged_in) self.session.on(spotify.SessionEvent.LOGGED_OUT, self.on_logged_out) self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def __init__(self, listener, controller): self.listener, self.controller = listener, controller self.session = spotify.Session() self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.logged_in = False self.playlist = None self.shuffledlist = None self.playlists = None self.track = None self.shuffle_mode = False self.playlist_length = 0 self.playlists_length = 0
def on_start(self): self._actor_proxy = self.actor_ref.proxy() self._session = self._get_session(self._config) self._event_loop = spotify.EventLoop(self._session) self._event_loop.start() self._session.login(self._config['spotify']['username'], self._config['spotify']['password']) self._web_client = web.OAuthClient( refresh_url='https://auth.mopidy.com/spotify/token', client_id=self._config['spotify']['client_id'], client_secret=self._config['spotify']['client_secret'], proxy_config=self._config['proxy'])
def __init__(self): self.is_logged_in = False # We assume a spotify_appkey.key is in the current directory self.session = spotify.Session() # Process Spotify events automatically in the background loop = spotify.EventLoop(self.session) loop.start() # Connect to the AlsaAudio Sink, which works best for the Pi if you're on Linux, # but otherwise connect to the more versatile PortAudio sink if platform.system() == "Linux": audio = spotify.AlsaSink(self.session) else: audio = spotify.PortAudioSink(self.session)
def __init__(self): print("init bohnify") self.listeners = [] self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.PLAY_TOKEN_LOST, self.on_play_token_lost) self.session.preferred_bitrate(spotify.Bitrate.BITRATE_160k) try: self.audio_driver = bohnifysink.BohnifyAlsaSink(self.session,self) except ImportError: print ('No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start() self.volumeController = Volume.Instance() self.volumeController.setListener(self) self.status["volume"] = self.volumeController.getVolume()
def __init__(self): cmd.Cmd.__init__(self) self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) try: self.audio_driver = spotify.AlsaSink(self.session) except ImportError: self.logger.warning( 'No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def on_start(self): self._actor_proxy = self.actor_ref.proxy() self._session = self._get_session(self._config) self._event_loop = spotify.EventLoop(self._session) self._event_loop.start() self._session.login( self._config["spotify"]["username"], self._config["spotify"]["password"], ) self._web_client = web.SpotifyOAuthClient( client_id=self._config["spotify"]["client_id"], client_secret=self._config["spotify"]["client_secret"], proxy_config=self._config["proxy"], ) self._web_client.login() if self.playlists is not None: self.playlists.refresh()
def initialize(): global session global logged_in global playlist global length config = pyspotify.Config() config.user_agent = 'smart' # config.tracefile = b'/tmp/libspotify-trace.log' #if sys.argv[1:]: # track_uri = sys.argv[1] #else: # track_uri = 'spotify:track:6xZtSE6xaBxmRozKA0F6TA' # Assuming a spotify_appkey.key in the current dir session = pyspotify.Session(config) session.login('johnwbird', 'bitterjava60', True) # Process events in the background loop = pyspotify.EventLoop(session) loop.start() # Connect an audio sink audio = pyspotify.AlsaSink(session) # Register event listeners session.on(pyspotify.SessionEvent.CONNECTION_STATE_UPDATED, on_connection_state_updated) session.on(pyspotify.SessionEvent.END_OF_TRACK, on_end_of_track) # Assuming a previous login with remember_me=True and a proper logout #session.relogin() logged_in.wait() playlist = session.get_playlist( 'spotify:user:spotify:playlist:5FJXhjdILmRA2z5bvz4nzf') playlist.load().name length = len(playlist.tracks) random.seed() curSong = random.randint(0, length - 1)
def __init__(self, session, queue): audio = spotify.AlsaSink(session) self.queue = queue self.session = session # Login logged_in_event = threading.Event() def connection_state_listener(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in_event.set() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, connection_state_listener) self.session.login(settings.SPOTIFY_USER, settings.SPOTIFY_PASS) while not logged_in_event.wait(0.1): self.session.process_events() # waits until the login is complete loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.END_OF_TRACK, self.end_of_track)
def start(credentials=None, disable_spotify_logging=True): if credentials is None: with Path(__file__).with_name('credentials.json').open() as f: credentials = json.load(f) c = credentials if 'appkey64' in c and 'appkey' not in c: import base64 c['appkey'] = base64.b64decode(c['appkey64']) logger.debug('loading pyspotify') import spotify if disable_spotify_logging: logging.getLogger('spotify').setLevel(logging.WARN) logger.debug("pyspotify loaded") cfg = spotify.Config() cfg.application_key = c['appkey'] cfg.cache_location = c['cachedir'] cfg.settings_location = c['cachedir'] global session session = spotify.Session(cfg) session.preferred_bitrate(spotify.Bitrate.BITRATE_320k) logged_in = threading.Event() def connection_state_changed(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in.set() loop = spotify.EventLoop(session) loop.start() session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, connection_state_changed) session.login(c['username'], c['password']) if not logged_in.wait(60): raise LoginError('Failed to login after 60 seconds') logger.debug("logged in to spotify")
def main(): if len(sys.argv) < 4: print('Input form: [username] [password] "[artist]"') exit() print('Logging in to Spotify') logged_in_event = threading.Event() def connection_state_listener(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in_event.set() session = spotify.Session() loop = spotify.EventLoop(session) loop.start() session.on( spotify.SessionEvent.CONNECTION_STATE_UPDATED, connection_state_listener) session.login(sys.argv[1], sys.argv[2]) logged_in_event.wait() create_artist_recommendations_playlist(session, sys.argv[3])
def run_player(self): login = open( 'login.txt', 'r' ) #login.txt should be your login with username on the top line and password next credentials = login.read().split('\n') self.session = spotify.Session() audio = spotify.AlsaSink(self.session) loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.is_loggedin) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.is_song_end) self.session.login(credentials[0], credentials[1]) self.logged_in_event.wait() print 'waiting' print 'logged in' playlist = self.session.playlist_container[-1] playlist.load() self.queue = [track for track in playlist.tracks] random.shuffle(self.queue)
def __init__(self, uname, pw, sink): self.userName = uname self.playlists = [] self.queue = deque() self.loggedIn = False self.status = "stopped" self.loggedInEvent = threading.Event() self.session = spotify.Session() if (sink == "alsa"): self.player = spotify.AlsaSink(self.session) elif (sink == "port"): self.player = spotify.PortAudioSink(self.session) else: print "unrecognized sink option: " + sink print "playback unavailable" self.loop = spotify.EventLoop(self.session) self.loop.start() self.session.on( spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.connectionListener ) self.session.on( spotify.SessionEvent.END_OF_TRACK, self.playNextTrack ) self.session.login(uname, pw) while not self.loggedInEvent.wait(0.1): self.session.process_events() self.loggedIn = True
def __init__(self): self.end_of_track = threading.Event() self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() log.debug("Spawning spotify.Session()") self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.tracks = [] myPlatform = platform.system() log.debug("Detecting platform") try: if myPlatform == 'Linux': log.info( "{0} platform detected; using ALSA".format(myPlatform)) self.audio_driver = spotify.AlsaSink(self.session) else: log.info("{0} platform detected; using PortAudio".format( myPlatform)) self.audio_driver = spotify.PortAudioSink(self.session) except ImportError as e: log.warning( 'No audio sink found; audio playback unavailable. Exception: {0}' .format(e.args)) # log.debug("spotify.Config()") # self.config = spotify.Config() # self.config.user_agent = 'Alarm Clock' log.debug("Spotify event loop") self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def _login(self): """Logs into Spotify to access playing music. A session attribute needs to be initiated first.""" # TODO: check that a session attribute has been initiated before setting login listeners # Set up event for "logged in" and a listener for the connection state self._logged_in = threading.Event() # Set up Pyspotify event loop _loop = spotify.EventLoop(self._session) _loop.start() # Register event listener self._session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self._logged_in_listener) # Login using environment variables self._session.login(os.environ['SPOTIFY_UN'], os.environ['SPOTIFY_PW']) # Blocks the thread until the event becomes True, which will be triggered # by _logged_in_listener (success handler), attached to the session # event listener self._logged_in.wait()