def get_player():
player = Playerctl.Player()
while not player.props.status:
print('No player found', flush=True)
player = Playerctl.Player()
time.sleep(3)
print(player.props.status, flush=True)
return player
def get_player():
if DEFAULT_PLAYER != '':
player_instance = Playerctl.Player(player_name=DEFAULT_PLAYER)
else:
for player_name in PLAYER_NAMES:
player_instance = Playerctl.Player(player_name=player_name)
if player_instance.props.status is not None:
return player_instance
player_instance = Playerctl.Player(player_name=PLAYER_NAMES[0])
return player_instance
def get_music_info():
player = Playerctl.Player()
status = player.get_property('status')
# handle when there is no player
if not status:
return
title = player.get_title()
artist = player.get_artist()
title_artist = ''
if title and len(title) > 0:
title_artist += title
if artist and len(artist) > 0:
title_artist += ' - ' + artist
if status == 'Paused':
title_artist += ' '
else:
title_artist += ' '
return title_artist.strip()
def main_loop():
# Try to connect Spotify through by a Playerctl instance, which
# is a dbus mpris interface to query some desktop player.
tries = 10
while tries:
player = Playerctl.Player(player_name='spotify')
if player.props.status:
break
tries -= 1
sleep(1)
if not tries:
print(
"(spotify_monitor_daemon_v1) Error connecting to Spotify Desktop")
sys.exit()
# Events an handlers: player.on( eventID, handlerFunction )
#player.on('play', on_play)
#player.on('pause', on_pause)
player.on('metadata', on_metadata) # This is enough
# Main loop waits for GLib events:
loop = GLib.MainLoop()
loop.run()
def get_art(cache_dir, size, client):
"""Get the album art."""
player = Playerctl.Player(player_name='spotify')
song = {
'artist': player.get_artist(),
'album': player.get_album(),
}
if len(song) < 2:
print("album: Nothing currently playing.")
return
file_name = f"{song['artist']}_{song['album']}_{size}.jpg".replace("/", "")
file_name = cache_dir / file_name
if file_name.is_file():
shutil.copy(file_name, cache_dir / "current.jpg")
print("album: Found cached art.")
else:
print("album: Downloading album art...")
os.system(
str('sacad "' + str(song['artist']) + '" "' + str(song['album']) +
'" "' + str(250) + '" "' + str(file_name) + '"'))
shutil.copy(file_name, cache_dir / "current.jpg")
def main():
player = Playerctl.Player(player_name='spotify')
vision = Thread(target=facer, args=(player, ))
main_loop = GLib.MainLoop()
vision.start()
main_loop.run()
vision.join()
def _init_player(self):
while True:
try:
self._player_name = getActivePlayer()
self._player_class = Playerctl.Player()
if self._player_name:
self._player = self._player_class.new(self._player_name)
else:
self._player = self._player_class.new()
self._player.on('metadata', self._on_metadata)
self._player.on('play', self._on_play)
self._player.on('pause', self._on_pause)
self._player.on('exit', self._on_exit)
status = self._player.get_property('status')
if status == 'Playing':
self._icon = MUSIC_ICON
elif status == 'Paused':
self._icon = PAUSE_ICON
self._on_metadata(self._player,
self._player.get_property('metadata'))
break
except:
self._print_flush(PLAYER_CLOSED_ICON)
time.sleep(2)
def run(self):
"""Main statement, executes all code every interval"""
# tries to create player object and get data from player
try:
self.player = Playerctl.Player()
response = self.get_info(self.player)
# creates a dictionary of the spotify data captured
fdict = {
'status': self.status[response['status'].lower()],
'title': response["title"],
'album': response.get('album', ''),
'artist': response.get('artist', ''),
'length': response.get('length', 0),
}
self.data = fdict
self.output = {"full_text": formatp(self.format, **fdict),
"color": self.color}
# outputs the not running string if spotify is closed
except:
self.output = {"full_text": self.format_not_running,
"color": self.color_not_running}
if hasattr(self, "data"):
del self.data
def main_loop(self):
""" Mainloop blocks so we thread it."""
self.player = Playerctl.Player()
self.player.on('metadata', self.set_status)
if self.player.props.status != "":
self.set_status(self.player)
main = GLib.MainLoop()
main.run()
def __init__(self):
self.status = None
self.albumart_data = None
self.indicator = AppIndicator3.Indicator.new(
'media_control_indicator',
'media-playback-stop',
AppIndicator3.IndicatorCategory.SYSTEM_SERVICES,
)
self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
self.menu = Gtk.Menu()
self.indicator.set_menu(self.menu)
self.albumart_item = Gtk.MenuItem()
self.np_item = Gtk.MenuItem()
self.play_button = Gtk.ImageMenuItem(
label='Play', image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PLAY))
self.previous_button = Gtk.ImageMenuItem(
label='Previous',
image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PREVIOUS),
)
self.next_button = Gtk.ImageMenuItem(
label='Next',
image=Gtk.Image(stock=Gtk.STOCK_MEDIA_NEXT),
)
self.play_button.connect('activate', self.media_play)
self.previous_button.connect('activate', self.media_previous)
self.next_button.connect('activate', self.media_next)
# Toggle play / pause on middle click
self.indicator.set_secondary_activate_target(self.play_button)
self.album_art = Gtk.Image()
self.albumart_item.add(self.album_art)
self.player = Playerctl.Player()
self.menu.append(self.albumart_item)
self.menu.append(self.np_item)
self.menu.append(self.play_button)
self.menu.append(self.previous_button)
self.menu.append(self.next_button)
GLib.timeout_add_seconds(1, self.set_np)
GLib.timeout_add_seconds(1, self.set_icon)
GLib.timeout_add_seconds(1, self.set_buttons)
GLib.timeout_add_seconds(1, self.player_handler)
GLib.timeout_add_seconds(30, self.collect_garbage)
self.update_album_art(None, None)
self.menu.show_all()
Gtk.main()
def on_track_change(player, e):
try:
if Playerctl.Player().get_properties('player-name')[0] == 'vlc':
imgpath = unquote(
os.popen(
"playerctl metadata mpris:artUrl").read()).replace(
'file://', '')
with open('artwork.jpg', 'wb') as artwork:
artwork.write(open(imgpath, 'rb').read())
img = '/static/artwork.jpg?{0}'.format(
Playerctl.Player().get_title())
else:
img = os.popen("playerctl metadata mpris:artUrl").read()
ws.send(
'%s,%s,%s,%s' % (img, Playerctl.Player().get_title(),
Playerctl.Player().get_artist(),
Playerctl.Player().get_property("status")))
except WebSocketError:
player.stop()
loop.quit()
ws.close()
def _init_player(self):
while True:
try:
self._player = Playerctl.Player()
self._player.on('metadata', self._on_metadata)
self._player.on('play', self._on_play)
self._player.on('pause', self._on_pause)
self._player.on('exit', self._on_exit)
break
except Exception as e:
time.sleep(2)
def _init_player(self):
while True:
try:
self._player = Playerctl.Player()
self._player.on('metadata', self._on_metadata)
self._player.on('play', self._on_play)
self._player.on('pause', self._on_pause)
self._player.on('exit', self._on_exit)
break
except:
self._print_flush(PLAYER_CLOSED_ICON)
time.sleep(2)
def run(self):
"""Main statement, executes all code every interval"""
self.player = pctl.Player(player_name=self.player_name)
fdict = self.get_formatted_info(self.player)
if fdict.get("status", ""):
self.output = {
"full_text": formatp(self.format, **fdict),
"color": self.color
}
else:
self.output = {
"full_text": self.format_not_running,
"color": self.color_not_running
}
def __initialize_player(self):
log.info('initializing player')
while True:
self._player = Playerctl.Player(player_name='vlc')
if self._player.get_property('status'):
break
else:
log.error("Couldn't find player, retrying...")
time.sleep(1)
self._player.connect('playback-status::playing', self._on_play)
self._player.connect('playback-status::paused', self._on_pause)
self._player.connect('playback-status::stopped', self._on_stop)
self._player.connect('seeked', self._on_seek)
self._player.connect('exit', self._on_exit)
self._player.connect('metadata', self._on_metadata)
def _setup_player(self):
player = Playerctl.Player()
self._player = player
player_name = player.get_property("player-name")
if player_name == None:
self._song_playing = False
self.cache_timeout = 5
else:
self.cache_timeout = 1
player.on("metadata", self._on_metadata)
player.on("stop", self._on_stop)
player.on("play", self._on_play)
player.on("pause", self._on_pause)
self._update_metadata(player.get_property("metadata"))
self._update_status()
pass
def main():
"""Main script function."""
args = get_args()
process_args(args)
disp = display.init(args.size)
client = Playerctl.Player(player_name='spotify')
song.get_art(args.cache_dir, args.size, client)
display.launch(disp, args.cache_dir / "current.jpg")
while True:
player_status = client.get_album()
time.sleep(3)
song.get_art(args.cache_dir, args.size, client)
display.launch(disp, args.cache_dir / "current.jpg")
def main(args):
if len(args) > 1 and os.path.exists(args[1]):
global music_root
music_root = args[1]
player_name = None
while not player_name:
player = Playerctl.Player()
player_name = player.get_property('player-name')
time.sleep(5)
logging.info(f"Mrec started, {player_name} found")
recording_data = {
'playing': False, # track is playing
'recording': True,
'track': Track()
} # track object to send data to
on_status(player, player.get_property('playback-status'), recording_data)
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.user_data_set(recording_data)
client.connect(broker, 1883, 60)
# callbacks:
player.connect('metadata', on_metadata, recording_data)
player.connect('playback-status', on_status, recording_data)
# threads:
capture_thread = threading.Thread(target=capture_input,
args=(recording_data, ),
daemon=True)
encode_thread = threading.Thread(target=encode_output, daemon=True)
capture_thread.start()
encode_thread.start()
client.loop_start()
main = GLib.MainLoop()
main.run()
return 0
def wait_for_player(self) -> None:
"""
Wait for an MPRIS-compatible player and bind its events.
:return: None
"""
while True:
try:
self.player = Playerctl.Player()
self.player.on('play', self.on_play)
self.player.on('pause', self.on_pause)
self.player.on('metadata', self.on_metadata)
self.player.on('exit', self.on_exit)
print('%{T2}栗%{T-} Stopped', flush=True)
break
except GLib.Error:
print('%{T2}ﱘ%{T-} No player running', flush=True)
time.sleep(2) # Wait before searching again
def print_status(player=None, metadata=None):
output = []
percentage_progress = 0
def append_output(data, fmt='{}'):
if data:
output.append(fmt.format(data))
global current_player
if player is None:
player = Playerctl.Player()
current_player = player
try:
player.on('play', on_change)
player.on('pause', on_change)
player.on('stop', on_change)
player.on('exit', on_change)
player.on('metadata', on_change)
if metadata is None:
metadata = player.get_property('metadata').unpack()
append_output(get_status(player))
append_output(player.get_property('player-name').strip('.'), '[{}]')
if player.get_property('status') != "Stopped":
position, percentage_progress = get_position(player, metadata)
append_output(position, '[{}]')
append_output(get_trackname(player, metadata), ' {}')
except:
output = []
global prev_output
output = ljust_clip(''.join(output), output_width)
if output != prev_output:
end_underline_pos = round(percentage_progress * output_width)
print('%{u#fff}' + output[:end_underline_pos] + '%{-u}' +
output[end_underline_pos:],
flush=True)
prev_output = output
return True
def echo(ws):
#print([obj for obj in gc.get_objects() if isinstance(obj, greenlet)])
#gevent.killall([obj for obj in gc.get_objects() if isinstance(obj, greenlet)])
print("connected")
if Playerctl.Player().get_properties('player-name')[0] == 'vlc':
imgpath = unquote(
os.popen("playerctl metadata mpris:artUrl").read()).replace(
'file://', '')
with open('artwork.jpg', 'wb') as artwork:
artwork.write(open(imgpath, 'rb').read())
img = '/static/artwork.jpg?{0}'.format(Playerctl.Player().get_title())
else:
img = os.popen("playerctl metadata mpris:artUrl").read()
ws.send(
'%s,%s,%s,%s' %
(img, Playerctl.Player().get_title(), Playerctl.Player().get_artist(),
Playerctl.Player().get_property("status")))
def on_track_change(player, e):
try:
if Playerctl.Player().get_properties('player-name')[0] == 'vlc':
imgpath = unquote(
os.popen(
"playerctl metadata mpris:artUrl").read()).replace(
'file://', '')
with open('artwork.jpg', 'wb') as artwork:
artwork.write(open(imgpath, 'rb').read())
img = '/static/artwork.jpg?{0}'.format(
Playerctl.Player().get_title())
else:
img = os.popen("playerctl metadata mpris:artUrl").read()
ws.send(
'%s,%s,%s,%s' % (img, Playerctl.Player().get_title(),
Playerctl.Player().get_artist(),
Playerctl.Player().get_property("status")))
except WebSocketError:
player.stop()
loop.quit()
ws.close()
player = Playerctl.Player()
player.on('metadata', on_track_change)
#GLib.timeout_add(100, checksocks, ws)
#print GLib.MainLoop().get_context().iteration()
loop = GLib.MainLoop()
#threading.Thread(target=checksocks, args=(player,loop)).run()
loop.run()
print("CLOSED!")
def set_buttons(self):
self.player = Playerctl.Player()
self.status = self.player.get_property('status')
if self.status == 'Playing':
self.play_button.set_sensitive(True)
self.next_button.set_sensitive(True)
self.previous_button.set_sensitive(True)
self.play_button.set_label('Pause')
self.play_button \
.set_image(image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PAUSE))
elif self.status == 'Paused':
self.play_button.set_sensitive(True)
self.next_button.set_sensitive(True)
self.previous_button.set_sensitive(True)
self.play_button.set_label('Play')
self.play_button \
.set_image(image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PLAY))
else:
self.play_button.set_sensitive(False)
self.next_button.set_sensitive(False)
self.previous_button.set_sensitive(False)
self.np_item.hide()
self.albumart_item.hide()
return GLib.SOURCE_CONTINUE
#!/usr/bin/env python3
from gi.repository import Playerctl, GLib
from subprocess import Popen
player = Playerctl.Player(player_name='spotify')
def on_play(player):
track_info = '{artist} - {title}'.format(artist=player.get_artist(),
title=player.get_title())
Popen(['notify-send', 'Now Playing:', track_info])
def on_pause(player):
track_info = '{artist} - {title}'.format(artist=player.get_artist(),
title=player.get_title())
Popen(['notify-send', 'Paused:', track_info])
player.on('play', on_play)
player.on('pause', on_pause)
GLib.MainLoop().run()
def main_loop(self):
""" Mainloop blocks so we thread it."""
self.player = Playerctl.Player()
self.player.on('metadata', self.on_track_change)
main = GLib.MainLoop()
main.run()
def player_is_running(player_name):
return Playerctl.Player(player_name=player_name).props.metadata is not None
def init():
"""Initialize player."""
return Playerctl.Player()
def run(self):
self.player = Playerctl.Player()
self.player.connect('playback-status', self.on_status)
self.player.connect('metadata', self.get_meta)
self.get_status()
self.get_meta()
def __init__(self, ):
self.player = Playerctl.Player()
self.show()
self.player.connect('playback-status', self.on_playback_status)
self.player.connect('metadata', self.on_metadata)
def on_seek(player, position):
mprisctl.send(('time-pos', position / 10**6))
print('Seeked to: {}'.format(position / 10**6))
def set_status(player, status):
statuses = ("Playing", "Paused", "Stopped")
status_fns = (on_play, on_pause, on_stop)
fn = status_fns[statuses.index(status)]
fn(player, status)
if args.instant_error:
player = Playerctl.Player()
else:
print("Waiting for connection")
while True:
try:
player = Playerctl.Player()
player.get_title()
except GLib.Error:
del player
time.sleep(2)
else:
break
print("Waiting for player")
while True:
try:
def handler(signum, frame):
raise TimeoutError
def on_metadata(player, e=None):
e = player.props.metadata if e is None else e
if player_is_running(PLAYER_NAME):
icon = ICON_PLAY if player.props.status == 'Playing' else ICON_PAUSE
print('{artist} - {title} {icon}'.format(artist=e['xesam:artist'][0],
title=e['xesam:title'],
icon=icon))
sys.exit(0)
if not player_is_running(PLAYER_NAME):
sys.exit()
#artist = player.props.metadata['xesam:artist']
#title = player.props.metadata['xesam:title']
player = Playerctl.Player(player_name=PLAYER_NAME)
player.on('metadata', on_metadata)
# wait for events
main = GLib.MainLoop()
#signal.signal(signal.SIGALRM, lambda n, f: main.quit())
#signal.alarm(1)
GLib.timeout_add_seconds(TIMEOUT, lambda: on_metadata(player))
main.run()
