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