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():
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 __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 __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 __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, 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 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
#!/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)
def get_player_status(show_track=False):
manager = Playerctl.PlayerManager()
available_players = manager.props.player_names
if not available_players:
return ""
for name in available_players:
player = Playerctl.Player.new_from_name(name)
try:
status = player.get_property('status')
if status == 'Playing':
break
except GLib.Error:
# player might not be running
return ""
try:
track = player.get_title()
artist = player.get_artist()
metadata = player.get_property('metadata')
# try extracting some data from metadata attribute
metadata = metadata.unpack()
if not track:
track = metadata.get("xesam:url").split("/")[-1]
# get information from vlc
try:
vlctitle = metadata['vlc:nowplaying'].strip()
try:
vlcartist, realtitle = vlctitle.split(" - ", 1)
artist = vlcartist
track = realtitle
except ValueError:
if vlctitle:
track = vlctitle
except KeyError:
# no further information available from vlc
pass
except AttributeError:
pass
# Fortmat output
playing = ""
if status:
if status.startswith("Playing"):
playing = "▶"
elif status.startswith("Paused"):
playing = "" # paused
elif status.startswith("Stopped"):
playing = "" #"\u23F9" # stop
else:
return ""
if artist:
artist = f"{artist[:10]}-"
else:
artist = ""
try:
track = re.split(
" -| \\(",
track)[0] # remove stuff like '- Radio Edit' aka make it short!
except TypeError:
track = ""
if show_track and status.startswith("Playing"):
playing = f"{playing} {artist}{track[:20]}"
return playing
