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)
