async def _server_callback(self, reader: asyncio.StreamReader,
writer: asyncio.StreamWriter) -> None:
"""Callback when a connection is made to the server
Read the data sent from the client, execute the requested command, and
send the reply back to the client.
"""
logger.debug("Connection made to server")
data = await reader.read()
logger.debug("EOF received by server")
try:
req, is_json = _IPC.unpack(data)
except IPCError:
logger.warn("Invalid data received, closing connection")
writer.close()
if sys.version_info >= (3, 7):
await writer.wait_closed()
return
if req[1] == "restart":
logger.debug("Closing connection on restart")
writer.write_eof()
rep = self.handler(req)
result = _IPC.pack(rep, is_json=is_json)
logger.debug("Sending result on receive EOF")
writer.write(result)
logger.debug("Closing connection on receive EOF")
writer.write_eof()
def remove_rule(self, rule_id):
rule = self.rules_map.get(rule_id)
if rule:
self.rules.remove(rule)
del self.rules_map[rule_id]
else:
logger.warn('Rule "%s" not found', rule_id)
def eof_received(self) -> None:
assert self.transport is not None
logger.debug('EOF received by server')
try:
req, is_json = _IPC.unpack(self.data)
except IPCError:
logger.warn('Invalid data received, closing connection')
self.transport.close()
return
finally:
self.data = None
if req[1] == 'restart':
logger.debug('Closing connection on restart')
self.transport.write_eof()
rep = self.handler(req)
if is_json:
result = _IPC.pack_json(rep)
else:
result = _IPC.pack(rep)
logger.debug('Sending result on receive EOF')
self.transport.write(result)
logger.debug('Closing connection on receive EOF')
self.transport.write_eof()
self.data = None
self.transport = None
def remove_rule(self, rule_id):
rule = self.rules_map.get(rule_id, None)
if rule:
self.rules.remove(rule)
del self.rules_map[rule_id]
else:
logger.warn('Rule "%s" not found', rule_id)
def getCmus(qtile:Optional[Qtile]=None, max_title_len:int=20):
try:
output = subprocess.check_output(['cmus-remote', '-Q']).decode()
except subprocess.CalledProcessError as e:
logger.warn("getMpd: {}".format(e))
return getIcons()['error']
else:
output = re.findall(r'file (.*)|duration (\d+)|position (\d+)|tag title (.*)', output, re.MULTILINE)
try:
if len(output) > 3:
title = output[3][-1].strip()
else:
title = output[0][0].split('/')[-1].split('.')[0].strip()
title = title[:max_title_len-3] + '...' if len(title) > max_title_len else "{}{}".format(
title, " "*(max_title_len-len(title)))
total_time_m = int(output[1][1])//60
total_time_s = int(output[1][1])%60
time_m = int(output[2][2])//60
time_s = int(output[2][2])%60
except Exception as e:
logger.warning("{} {}".format(e, output))
return getIcons()['error']
else:
return "{} {}:{}/{}:{}".format(title, time_m, time_s, total_time_m, total_time_s)
async def _server_callback(self, reader: asyncio.StreamReader,
writer: asyncio.StreamWriter) -> None:
"""Callback when a connection is made to the server
Read the data sent from the client, execute the requested command, and
send the reply back to the client.
"""
try:
logger.debug("Connection made to server")
data = await reader.read()
logger.debug("EOF received by server")
req, is_json = _IPC.unpack(data)
except IPCError:
logger.warn("Invalid data received, closing connection")
else:
if req[1] == "restart":
# if we are going to restart, close the connection first, as we won't be back
logger.debug("Closing connection on restart")
writer.write_eof()
rep = self.handler(req)
result = _IPC.pack(rep, is_json=is_json)
logger.debug("Sending result on receive EOF")
writer.write(result)
logger.debug("Closing connection on receive EOF")
writer.write_eof()
finally:
writer.close()
await writer.wait_closed()
def cmd_playstop_radio(self):
if not self.playlist:
return
logger.warn('cmd_playstop_radio')
if self.player.get_state() == vlc.State.Playing:
self.player.stop()
elif self.player.get_media() == None or self.player.get_state(
) == vlc.State.Ended or self.player.get_state() == vlc.State.Stopped:
radioItemKey = list(self.playlist)[self.playlistIdx]
media = self.vlcInstance.media_new(self.playlist[radioItemKey])
self.player.set_media(media)
self.player.play()
def _getSinks(fullDetails=True):
sinks = []
active = {}
if fullDetails:
cmd = "pacmd list sinks"
try:
pacmd = check_output(cmd.split()).decode()
except CalledProcessError as e:
logger.warn("Error while getting current sinks: {}".format(e))
return [], {}
_sink_details = GET_SINK_DETAILS_RE.search(pacmd).group()
_sinks = SINK_DETAILS_RE.findall(_sink_details)
this_sink = {}
for index, found in enumerate(_sinks):
_index = index if index < 3 else index - 3
if _index == 0:
if not found[1]:
logger.warn(f'Audio/GetSinks: Empty index: {_sinks}')
return [], {}
this_sink = {
'index': found[1],
'active': True if found[0] == "*" else False,
'position': len(sinks)
}
elif _index == 1:
if not found[2] and not found[3]:
logger.warn(f'Audio/GetSinks: Empty volume: {_sinks}')
return [], {}
this_sink['volume'] = int(found[3]) if not found[2] else int(
found[2])
elif _index == 2:
if not found[4]:
logger.warn(f'Audio/GetSinks: Empty mute flag: {_sinks}')
return [], {}
this_sink['muted'] = True if found[4] == 'yes' else 'False'
sinks.append(dict(this_sink))
if this_sink['active']:
active = dict(this_sink)
this_sink = {}
else:
sinksCmd = "pactl list short sinks|awk '{print $1}'"
try:
sinks = check_output(sinksCmd, shell=True).decode().strip().split()
except CalledProcessError as e:
logger.warn("Error while getting current sinks: {}".format(e))
return [], {}
# logger.warn(sinks)
return sinks, active
def cmd_exec_general(self,
prompt,
object_name,
cmd_name,
selector=None,
completer=None):
"""
Execute a cmd of any object. For example layout, group, window, widget
, etc with a string that is obtained from startInput.
Parameters
==========
prompt :
Text displayed at the prompt.
object_name :
Name of a object in Qtile. This string has to be 'layout', 'widget',
'bar', 'window' or 'screen'.
cmd_name :
Execution command of selected object using object_name and selector.
selector :
This value select a specific object within a object list that is
obtained by object_name.
If this value is None, current object is selected. e.g. current layout,
current window and current screen.
completer:
Completer to use.
config example:
Key([alt, 'shift'], 'a',
lazy.widget['prompt'].exec_general(
'section(add)',
'layout',
'add_section'))
"""
try:
obj = self.qtile.select([(object_name, selector)])
except _SelectError:
logger.warn("cannot select a object")
return
cmd = obj.command(cmd_name)
if not cmd:
logger.warn("command not found")
return
def f(args):
if args:
cmd(args)
self.startInput(prompt, f, completer)
def autostart():
processes = [
['sh', '.xinitrc'],
['nitrogen', '--restore'],
['picom', '-b'],
['dex', '-a'],
['redshift-gtk'],
['kdeconnect-indicator'],
['keepassxc'],
]
for p in processes:
try:
subprocess.Popen(p)
except Exception as e:
logger.warn('Failed to start {}'.format(' '.join(p)), e)
logger.info("Finished starting sub-processes")
def cmd_exec_general(
self, prompt, object_name, cmd_name, selector=None, completer=None):
"""
Execute a cmd of any object. For example layout, group, window, widget
, etc with a string that is obtained from start_input.
Parameters
==========
prompt :
Text displayed at the prompt.
object_name :
Name of a object in Qtile. This string has to be 'layout', 'widget',
'bar', 'window' or 'screen'.
cmd_name :
Execution command of selected object using object_name and selector.
selector :
This value select a specific object within a object list that is
obtained by object_name.
If this value is None, current object is selected. e.g. current layout,
current window and current screen.
completer:
Completer to use.
config example:
Key([alt, 'shift'], 'a',
lazy.widget['prompt'].exec_general(
'section(add)',
'layout',
'add_section'))
"""
try:
obj = self.qtile.select([(object_name, selector)])
except _SelectError:
logger.warn("cannot select a object")
return
cmd = obj.command(cmd_name)
if not cmd:
logger.warn("command not found")
return
def f(args):
if args:
cmd(args)
self.start_input(prompt, f, completer)
async def _server_callback(self, reader: asyncio.StreamReader,
writer: asyncio.StreamWriter) -> None:
"""Callback when a connection is made to the server
Read the data sent from the client, execute the requested command, and
send the reply back to the client.
"""
try:
logger.debug("Connection made to server")
data = await reader.read()
logger.debug("EOF received by server")
req, is_json = _IPC.unpack(data)
except IPCError:
logger.warn("Invalid data received, closing connection")
else:
if req[1] == "restart":
# if we are going to restart, close the connection first, as we won't be back
logger.debug("Closing connection on restart")
writer.write_eof()
rep = self.handler(req)
result = _IPC.pack(rep, is_json=is_json)
logger.debug("Sending result on receive EOF")
writer.write(result)
logger.debug("Closing connection on receive EOF")
writer.write_eof()
finally:
# the resoure isn't closed immediately on the close call, but is on
# the next loop iteration, this is exposed as the wait_closed
# method in 3.7, but requires a manual loop iteration in earlier
# versions
writer.close()
if sys.version_info >= (3, 7):
await writer.wait_closed()
else:
await asyncio.sleep(0)
def getNetSpeeds(interface:str="wlo1", show_speed_above:int=1e3):
# get speeds
global net_speed_objects
speed_obj = None
for o in net_speed_objects:
if o.interface == interface:
speed_obj = o
if speed_obj is None:
speed_obj = NetSpeeds(interface=interface)
net_speed_objects.append(speed_obj)
try:
speeds = speed_obj.getSpeed()
except Exception as e:
logger.warn("getNetSpeeds error: {}".format(e))
def format_speed(speed:int):
return "{:3.0f} kB/s".format(speed/1e3) if speed < 1e6 else "{:2.1f} MB/s".format(speed/1e6)
for k in speeds:
speeds[k] = format_speed(speeds[k]) if speeds[k] > show_speed_above else ""
return speeds
def cmd_mute_radio(self):
logger.warn('mute_radio')
if self.player.get_state() == vlc.State.Playing:
self.player.audio_set_mute(not self.player.audio_get_mute())
def main(qtile):
if uvloop:
logger.warn('set uvloop')
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
def _configure(self, *args):
super()._configure(*args)
self.show(False)
logger.warn('is_show: %r', self.is_show())
