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 __init__(self): self.player = None for player in Playerctl.list_players(): self.on_name_appeared(None, player) self.player_manager = Playerctl.PlayerManager() self.player_manager.connect('name-appeared', self.on_name_appeared) self.player_manager.connect('name-vanished', self.on_name_vanished) print('{}'.format(STOPPED), flush=True) self.main = GLib.MainLoop() self.main.run()
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 _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 main(): arguments = parse_arguments() # Initialize logging logging.basicConfig(stream=sys.stderr, level=logging.DEBUG, format='%(name)s %(levelname)s %(message)s') # Logging is set by default to WARN and higher. # With every occurrence of -v it's lowered by one logger.setLevel(max((3 - arguments.verbose) * 10, 0)) # Log the sent command line arguments logger.debug('Arguments received {}'.format(vars(arguments))) manager = Playerctl.PlayerManager() loop = GLib.MainLoop() manager.connect('name-appeared', lambda *args: on_player_appeared(*args, arguments.player)) manager.connect('player-vanished', on_player_vanished) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) for player in manager.props.player_names: if arguments.player is not None and arguments.player != player.name: logger.debug( '{player} is not the filtered player, skipping it'.format( player=player.name)) continue init_player(manager, player) loop.run()
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 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 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(): arguments = parse_arguments() # Initialize logging LOG = home+"/.dotfiles/configs/waybar/media.log" logger.setLevel(max((3 - arguments.verbose) * 10, 0)) logging.basicConfig(stream=sys.stderr, filename=LOG, level=logging.DEBUG, format='%(name)s %(levelname)s %(message)s') logger.setLevel(0) # Log the sent command line arguments logger.debug('Arguments received {}'.format(vars(arguments))) manager = Playerctl.PlayerManager() loop = GLib.MainLoop() manager.connect('name-appeared', lambda *args: on_player_appeared(*args, arguments.player)) manager.connect('player-vanished', on_player_vanished) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) for player in manager.props.player_names: if arguments.player is not None and arguments.player != player.name: logger.debug('{player} is not the filtered player, skipping it' .format(player=player.name) ) continue init_player(manager, player) update_song() 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 __init__( self, player_name, stream: VideoStream, detector: FaceDetector, logdir: Path, metric_name: str, debug: bool, ) -> None: """The controller. It controls your player, tracks and classify your face.""" self._desired_player = player_name self._manager = Playerctl.PlayerManager() self._manager.connect("name-appeared", self._on_name_appeared) self._manager.connect("name-vanished", self._on_name_vanished) self._player = None self._stream = stream self._detector = detector self._debug = debug self._expansion = (70, 70) self._counters = {hit: 0 for hit in ClassificationResult} # FPS value of this application. It has nothing to the with the # VideoStram.fps value. self._fps = -1 with open(logdir / "on" / "best" / metric_name / (metric_name + ".json")) as json_fp: json_file = json.load(json_fp) thresholds = Thresholds( on={ "mean": float(json_file.get("positive_threshold", -1)), "variance": float(json_file.get("positive_variance", -1)), }, off={ "mean": float(json_file.get("negative_threshold", -1)), "variance": float(json_file.get("negative_variance", -1)), }, ) model = tf.saved_model.load(str(logdir / "on" / "saved")) self._classifier = Classifier( model=model, thresholds=thresholds, debug=self._debug, ) # These 3 bools control the player using the camera self._play = False self._stop = False self._pause = False # However, we need to let the user control the player # thus we set another flag that is set only if the play(),pause(),stop() # methods have been called from this application. self._internal = False # Start main loop glib_loop = GLib.MainLoop() glib_loop.run()
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, **kwargs): super().__init__(application_id='com.aymanbagabas.Glyrics', flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, **kwargs) self.playermanager = Playerctl.PlayerManager() self.player = None self.add_main_option("version", ord("v"), GLib.OptionFlags.NONE, GLib.OptionArg.NONE, "Show Glyrics version", None)
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 _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 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: 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 __init__(self, q, conf, name): super().__init__(q, conf, name) self.font_col = conf['font_color'] self.manager = Playerctl.PlayerManager() self.string = Utilities.f_colour('No Media Playing', self.font_col) def init_player(name): player = Playerctl.Player.new_from_name(name) player.connect('playback-status::stopped', self.on_stopped, self.manager) player.connect('playback-status::playing', self.on_change, self.manager) player.connect('metadata', self.on_change, self.manager) self.manager.manage_player(player) self.manager.connect('name-appeared', lambda manager, name: init_player(name)) for name in self.manager.props.player_names: init_player(name)
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 get_playing_media_name(): players = [] man=Playerctl.PlayerManager().props.player_names for name in man: # Iterate over every media player try: # A media player's properties may sometimes be unavailable for some reason player = Playerctl.Player.new_from_name(name) try: # Try getting title title = player.get_title() if len(title)==0: # Title is empty continue except Exception: # Couldn't get title - happens when there is no media player. continue artist = player.get_artist() try: pos = time.strftime("%H:%M:%S", time.gmtime(max(player.get_position()/1000000, 0))) except gi.repository.GLib.Error: # Player position may be not supported pos = None if 'mpris:length' in player.props.metadata.keys(): length = time.strftime("%H:%M:%S", time.gmtime(player.props.metadata['mpris:length']/1000000)) else: length=None if (artist is None) & (title is None): continue #return "" # No valid media data yet output="" if artist is not None: if len(artist)>0: output+=artist+" - " output+=title if pos is not None: output+=" ("+pos if length is not None: output+="/"+length output+=")" players.append( (output, player.props.status) ) except Exception: players.append( ("?", "?") ) continue return players
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 """ A simple Discord Rich Presence client that connects to MPRIS and shows your current song. """ import sys import time import gi gi.require_version('Playerctl', '2.0') from gi.repository import Playerctl, GLib from pypresence import Presence import pypresence.exceptions manager = Playerctl.PlayerManager() print("Starting RPC client...") RPC = Presence('440997014315204609') def connect_rpc(): while True: try: RPC.connect() print("RPC client connected") break except ConnectionRefusedError as e: print("Failed to connect to RPC! Trying again in 10 seconds...") time.sleep(10) except (FileNotFoundError, AttributeError) as e: print("RPC failed to connect due to Discord not being opened yet. Please open it. Reconnecting in 10 seconds...") time.sleep(10)