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