aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--examples/compact2756
1 files changed, 2756 insertions, 0 deletions
diff --git a/examples/compact b/examples/compact
new file mode 100644
index 0000000..6ba9fe7
--- /dev/null
+++ b/examples/compact
@@ -0,0 +1,2756 @@
+# -*- python -*-
+'''
+xpybar – xmobar replacement written in python
+Copyright © 2014, 2015, 2016 Mattias Andrée (maandree@member.fsf.org)
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+'''
+
+# This is a template configuration of a panel that can display almost
+# all information and control, but suited for a height constrained screen
+
+# It is recommended to have python-posix_ipc and
+# <https://github.com/maandree/pdeath> installed
+
+import os
+import sys
+import pwd
+import time
+import threading
+import subprocess
+
+from util import *
+
+from plugins.alsa import ALSA
+from plugins.clock import Clock
+from plugins.cpu import CPU
+from plugins.cpuinfo import CPUInfo
+from plugins.cpuonline import CPUOnline
+from plugins.dentrystate import DentryState
+from plugins.df import Discs
+from plugins.discstats import DiscStats
+from plugins.files import Files
+from plugins.inodestate import InodeState
+from plugins.ipaddress import IPAddress
+from plugins.leapsec import LeapSeconds
+from plugins.loadavg import AverageLoad
+from plugins.locks import Locks
+from plugins.mem import Memory
+from plugins.moc import MOC
+from plugins.network import Network
+from plugins.pacman import Pacman
+from plugins.ping import Ping
+from plugins.random import Random
+from plugins.snmp import SNMP
+from plugins.snmp6 import SNMP6
+from plugins.softirqs import SoftIRQs
+from plugins.swaps import Swaps
+from plugins.tzclock import TZClock
+from plugins.uname import Uname
+from plugins.uptime import Uptime
+from plugins.users import Users
+from plugins.vmstat import VMStat
+from plugins.weather import Weather
+from plugins.xdisplay import XDisplay
+from plugins.xkb import XKB
+#from plugins.application import Application
+#from plugins.hdparm import HDParm
+#from plugins.image import Image
+#from plugins.kmsg import KMsg
+#from plugins.lunar import Lunar
+#from plugins.menu import Menu
+#from plugins.ropty import ROPTY
+#from plugins.solar import Solar
+
+import Xlib.X, Xlib.XK, Xlib.protocol.event
+
+
+
+OUTPUT, HEIGHT_PER_LINE, YPOS, TOP = 0, 12, 0, True
+
+clock = Clock(sync_to = 0.5)
+
+TERMINAL = 'terminator'
+
+
+
+LEFT_BUTTON = 1
+MIDDLE_BUTTON = 2
+RIGHT_BUTTON = 3
+SCROLL_UP = 4
+SCROLL_DOWN = 5
+FORWARD_BUTTON = 8 # X1
+BACKWARD_BUTTON = 9 # X2
+
+
+
+limited = lambda v : min(max(int(v + 0.5), 0), 100)
+
+def t_(f):
+ try:
+ f()
+ except:
+ time.sleep(1)
+
+t = lambda f : (lambda : t_(f))
+
+def pdeath(signal, *command):
+ try:
+ path = os.environ['PATH'].split(':')
+ for p in path:
+ p += '/pdeath'
+ if os.access(p, os.F_OK | os.X_OK, effective_ids = True):
+ return (p, signal, *command)
+ except:
+ pass
+ return command
+
+HOME = pwd.getpwuid(os.getuid()).pw_dir
+
+
+
+SEPARATOR = ' │ '
+
+def invalidate():
+ try:
+ bar.invalidate()
+ except:
+ pass
+
+class Entry:
+ def __init__(self, wrap = None, left = True, line = 0, prev = None):
+ self.left = left
+ self.line = line
+ self.prev = prev
+ self.width = 0
+ self.offset = 0
+ self.last_text = None
+ self.short_layout = None
+ self.wrapped = self.function if wrap is None else wrap(self.function)
+
+ def invalidate(self):
+ wrapper = self.wrapped
+ if isinstance(wrapper, Clocked):
+ wrapper = wrapper.sometimes
+ if isinstance(wrapper, Sometimes):
+ wrapper.counter = 0
+ invalidate()
+
+ def action(self, col, button, x, y):
+ pass
+
+ def click(self, row, lcol, rcol, button, x, y):
+ if row == self.line:
+ col = (lcol if self.left else rcol) - self.offset
+ if 0 <= col < self.width:
+ if self.left:
+ x -= self.offset * bar.font_width
+ else:
+ col = self.width - 1 - col
+ x = bar.width - x
+ x -= self.offset * bar.font_width
+ x = self.width * bar.font_width - x
+ y -= self.line * HEIGHT_PER_LINE
+ try:
+ self.action(col, button, x, y)
+ except Exception as err:
+ print(str(err), file = sys.stderr, flush = True)
+ return True
+ return False
+
+ def function(self):
+ return SEPARATOR
+
+ def __call__(self, *args, **kwargs):
+ try:
+ text = self.wrapped(*args, **kwargs)
+ if text is not self.last_text:
+ self.width = Bar.coloured_length(text)
+ self.last_text = text
+ return text
+ except Exception as err:
+ print(err)
+
+ def update_position(self):
+ if self.prev is not None:
+ self.prev.update_position()
+ self.offset = self.prev.offset + self.prev.width
+
+class Group:
+ def __init__(self, functions):
+ global HEIGHT
+ self.pattern = ''
+ self.posupdate = []
+ left = None
+ right = None
+ lineno = 0
+ atleft = True
+ newline = False
+ lastright = None
+ new_functions = []
+ separator = None
+ for entry in functions:
+ if entry is None:
+ newline = not atleft
+ lineno += 1 if newline else 0
+ atleft = not atleft
+ continue
+ entry.left = atleft
+ entry.line = lineno
+ if newline:
+ self.pattern += '\n'
+ newline = False
+ if left is not None:
+ self.posupdate.append(left)
+ if right is not None:
+ self.posupdate.append(right)
+ left = None
+ right = None
+ lastright = None
+ if entry.left:
+ if left is not None:
+ separator = Entry(left = True)
+ new_functions.append(separator)
+ self.pattern += '%s'
+ separator.prev = left
+ left = separator
+ entry.prev = left
+ left = entry
+ elif right is None:
+ if left is not None:
+ self.pattern += '\0 '
+ right = entry
+ lastright = entry
+ else:
+ separator = Entry(left = False)
+ new_functions.append(separator)
+ self.pattern += '%s'
+ lastright.prev = separator
+ separator.prev = entry
+ lastright = entry
+ new_functions.append(entry)
+ self.pattern += '%s'
+ if left is not None:
+ self.posupdate.append(left)
+ if right is not None:
+ self.posupdate.append(right)
+ height = (lineno + 1) * HEIGHT_PER_LINE
+ if HEIGHT < height:
+ HEIGHT = height
+ self.functions = new_functions
+
+
+
+class MyXMonad(Entry):
+ def __init__(self, *args, mod = Xlib.XK.XK_Super_L, ppWsSep = '', ppSep = ' ', **kwargs):
+ self.text = ''
+ self.text_short = ''
+ self.ws_sep_len = len(ppWsSep)
+ self.sep_len = len(ppSep)
+ self.mod = mod
+ self.show_full = False
+ self.short_layout = None
+ Entry.__init__(self, *args, **kwargs)
+ async(lambda : forever(t(self.refresh)), name = 'xmonad')
+
+ def action(self, col, button, x, y):
+ if button == MIDDLE_BUTTON:
+ self.show_full = not self.show_full
+ self.invalidate()
+ return
+ text = self.text
+ full = self.show_full
+ UTF8_STRING = display.intern_atom('UTF8_STRING')
+ _XMONAD_LOG = display.intern_atom('_XMONAD_LOG')
+ _NET_DESKTOP_NAMES = display.intern_atom('_NET_DESKTOP_NAMES')
+ xmonad_log = display.screen().root.get_full_property(_XMONAD_LOG, UTF8_STRING).value
+ xmonad_log = xmonad_log.split(' : ')
+ net_desktop_names = display.screen().root.get_full_property(_NET_DESKTOP_NAMES, UTF8_STRING).value
+ net_desktop_names = net_desktop_names[:-1].split('\0')
+ ws = 0
+ ws_hit = False
+ while ws < len(net_desktop_names):
+ if ws > 0:
+ col -= self.ws_sep_len
+ if col < 0:
+ break
+ width = len(net_desktop_names[ws] if full else str(ws + 1)) + 2
+ if col < width:
+ ws_hit = True
+ break
+ ws += 1
+ col -= width
+ if ws < len(net_desktop_names):
+ if button == LEFT_BUTTON:
+ self.switch_workspace(ws + 1)
+ elif button in (SCROLL_UP, SCROLL_DOWN):
+ xmonad_log = xmonad_log[0].split(' ')
+ active = [net_desktop_names.index(w[1:-1]) for w in xmonad_log if w[:1] == '<']
+ ws = [net_desktop_names.index(w[1:-1]) for w in xmonad_log if w[:1] == '['][0]
+ ws += -1 if button == SCROLL_UP else +1
+ ws %= len(net_desktop_names)
+ while ws in active:
+ ws += -1 if button == SCROLL_UP else +1
+ ws %= len(net_desktop_names)
+ self.switch_workspace(ws + 1)
+ elif button == LEFT_BUTTON:
+ col -= self.sep_len
+ layout = xmonad_log[1]
+ if not self.show_full and self.short_layout is not None:
+ layout = self.short_layout
+ if col < len(layout) + 2:
+ display.xtest_fake_input(Xlib.X.KeyPress, display.keysym_to_keycode(self.mod))
+ display.xtest_fake_input(Xlib.X.KeyPress, display.keysym_to_keycode(Xlib.XK.XK_space))
+ display.xtest_fake_input(Xlib.X.KeyRelease, display.keysym_to_keycode(Xlib.XK.XK_space))
+ display.xtest_fake_input(Xlib.X.KeyRelease, display.keysym_to_keycode(self.mod))
+ display.flush()
+
+ def refresh(self):
+ try:
+ text = input()
+ except:
+ sys.exit(0)
+ buf, esc = '', None
+ for c in text:
+ if esc is not None:
+ esc += c
+ if esc == '^':
+ buf += '^'
+ esc = None
+ elif esc[-1] == ')':
+ if esc.startswith('bg(') or esc.startswith('fg('):
+ c = 4 if esc.startswith('bg(') else 3
+ esc = esc[3 : -1]
+ if esc == '':
+ buf += '\033[%i9m' % c
+ else:
+ r, g, b = esc[1 : 3], esc[3 : 5], esc[5 : 7]
+ r, g, b = int(r, 16), int(g, 16), int(b, 16)
+ r, g, b = str(r), str(g), str(b)
+ buf += '\033[%i8;2;%sm' % (c, ';'.join([r, g, b]))
+ esc = None
+ elif c == '^':
+ esc = ''
+ else:
+ buf += c
+ self.text = buf
+ short = ''
+ space, esc, layout, lbuf = False, False, 0, ''
+ ws = 1
+ for c in buf:
+ if esc:
+ short += c
+ esc = not (c == '~' or 'a' <= c.lower() <= 'z')
+ elif c == '\033':
+ esc = True
+ if layout == 2:
+ layout = 3
+ end = ''
+ while lbuf.startswith(' '):
+ short += ' '
+ lbuf = lbuf[1:]
+ while lbuf.endswith(' '):
+ end += ' '
+ lbuf = lbuf[:-1]
+ self.short_layout = self.shorten_layout(lbuf)
+ short += self.short_layout + end
+ short += c
+ elif ws <= 9:
+ if c in ' <>[]':
+ space = not space
+ if not space:
+ short += '%i' % ws
+ ws += 1
+ if ws == 10:
+ layout = 1
+ short += c
+ elif not space:
+ short += c
+ elif layout == 1:
+ if c == ' ':
+ short += c
+ else:
+ layout = 2
+ lbuf += c
+ elif layout == 2:
+ lbuf += c
+ else:
+ short += c
+ self.text_short = short
+ self.invalidate()
+
+ def shorten_layout(self, text):
+ text = text.split(' ')
+ incl = []
+ for word in text:
+ if word not in ('ImageButtonDeco', 'Maximize', 'Minimize'):
+ incl.append(word)
+ return ' '.join(incl).replace('Mirror ', '\\')
+
+ def switch_workspace(self, ws):
+ display.xtest_fake_input(Xlib.X.KeyPress, display.keysym_to_keycode(self.mod))
+ display.xtest_fake_input(Xlib.X.KeyPress, display.keysym_to_keycode(Xlib.XK.XK_0 + ws))
+ display.xtest_fake_input(Xlib.X.KeyRelease, display.keysym_to_keycode(Xlib.XK.XK_0 + ws))
+ display.xtest_fake_input(Xlib.X.KeyRelease, display.keysym_to_keycode(self.mod))
+ display.flush()
+
+ def function(self):
+ return self.text if self.show_full else self.text_short
+
+
+class MyScroll(Entry):
+ def function(self):
+ return '↓↑'
+
+ def action(self, col, button, x, y):
+ global groups, groupi, group
+ if button in (LEFT_BUTTON, RIGHT_BUTTON, SCROLL_UP, SCROLL_DOWN):
+ groupi = (groupi + (+1 if button in (LEFT_BUTTON, SCROLL_DOWN) else -1)) % len(groups)
+ group = groups[groupi]
+ self.invalidate()
+
+
+class MyClock(Entry):
+ def __init__(self, *args, format = '%Y-%m-%d %T', long_format = '%Y-(%m)%b-%d %T, %a w%V, %Z', tzs = None, **kwargs):
+ self.default_format = format
+ self.long_format = long_format
+ self.clock = clock
+ self.set_format(self.clock, self.default_format)
+ self.tzs = [] if tzs is None else tzs
+ self.tzi = 0
+ mqueue_map['timefmt'] = self.mqueue
+ mqueue_map['tz'] = self.mqueue
+ Entry.__init__(self, *args, **kwargs)
+
+ def mqueue(self, args):
+ if args[0] == 'timefmt':
+ args = args[1:]
+ if len(args) == 0:
+ self.action(0, RIGHT_BUTTON, 0, 0)
+ else:
+ self.set_format(self.clock, ' '.join(args))
+ self.invalidate()
+ if args[0] == 'tz':
+ args = args[1:]
+ if len(args) == 0:
+ self.action(0, LEFT_BUTTON, 0, 0)
+ else:
+ old_clock = self.clock
+ tz = '/'.join(args)
+ try:
+ tzclock = TZClock(timezone = tz, format = self.clock.u_format)
+ except:
+ try:
+ tzclock = TZClock(timezone = tz.upper(), format = self.clock.u_format)
+ except:
+ print('%s: unknown typezone: %s' % (sys.argv[0], tz), file = sys.stderr, flush = True)
+ return
+ tzclock.u_format = tzclock.format
+ self.clock = tzclock
+ if old_clock is not clock:
+ del old_clock
+ self.invalidate()
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ if self.clock is clock:
+ clock.utc = not clock.utc
+ self.set_format(clock, self.clock.u_format)
+ else:
+ self.set_format(clock, self.clock.u_format)
+ self.clock = clock
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ if self.clock.u_format == self.default_format:
+ self.set_format(self.clock, self.long_format)
+ else:
+ self.set_format(self.clock, self.default_format)
+ self.invalidate()
+ elif button in (SCROLL_UP, SCROLL_DOWN):
+ i = self.tzi + (+1 if button == SCROLL_UP else -1)
+ if not (0 <= i <= len(self.tzs)):
+ return
+ self.tzi = i
+ old_clock = self.clock
+ if i > 0:
+ tzclock = TZClock(timezone = self.tzs[i - 1], format = self.clock.u_format)
+ tzclock.u_format = tzclock.format
+ self.clock = tzclock
+ else:
+ self.clock = clock
+ if old_clock is not clock:
+ del old_clock
+ self.invalidate()
+
+ def set_format(self, clck, format):
+ clck.u_format = format
+ if not (clck is clock and clck.utc):
+ clck.format = format
+ else:
+ fmt, esc = '', False
+ for c in format:
+ if esc:
+ fmt += c
+ if c == '%' or 'a' <= c.lower() <= 'z':
+ esc = False
+ if c == 'Z':
+ while fmt[-1] != '%':
+ fmt = fmt[:-1]
+ fmt = fmt[:-1] + 'UTC'
+ elif c == '%':
+ esc = True
+ fmt += c
+ else:
+ fmt += c
+ clck.format = fmt
+
+ def function(self):
+ clck = self.clock
+ colour = '0'
+ if clck is not clock or clck.utc:
+ colour += ';7'
+ return '\033[%sm%s\033[00m' % (colour, clck.read())
+
+
+class MyComputer(Entry):
+ def __init__(self, *args, locks = None, **kwargs):
+ self.have_linux_libre, self.have_pacman = True, None
+ self.linux_installed, self.linux_latest = None, None
+ self.last_uname_read = ''
+ self.last_users_read = ''
+ self.xdisplay = None
+ self.you = pwd.getpwuid(os.getuid()).pw_name
+ self.display = 0
+ self.show_detailed = False
+ self.keys = []
+ if locks is None:
+ locks = ['num', 'cap']
+ self.num_lock = 'num' in locks or 'number' in locks or 'numerical' in locks or 'numpad' in locks
+ self.cap_lock = 'cap' in locks or 'caps' in locks
+ self.scr_lock = 'scr' in locks or 'scroll' in locks or 'scrl' in locks
+ if self.num_lock:
+ self.keys.append(Xlib.XK.XK_Num_Lock)
+ if self.cap_lock:
+ self.keys.append(Xlib.XK.XK_Caps_Lock)
+ if self.scr_lock:
+ self.keys.append(Xlib.XK.XK_Scroll_Lock)
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ if self.display == 3:
+ col -= 5
+ if col % 4 == 3:
+ return
+ col //= 4
+ key = self.keys[col]
+ display.xtest_fake_input(Xlib.X.KeyPress, display.keysym_to_keycode(key))
+ display.xtest_fake_input(Xlib.X.KeyRelease, display.keysym_to_keycode(key))
+ display.flush()
+ elif button == MIDDLE_BUTTON:
+ self.show_detailed = not self.show_detailed
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ if self.display == 0:
+ async(lambda : subprocess.Popen(['mate-system-monitor']).wait())
+ else:
+ self.invalidate()
+ elif button == SCROLL_UP:
+ self.display = min(self.display + 1, 2) ## TODO the keyboard support is not too good
+ self.invalidate()
+ elif button == SCROLL_DOWN:
+ self.display = max(self.display - 1, 0)
+ self.invalidate()
+
+ def function_uname(self):
+ uname = Uname()
+ nodename = uname.nodename
+ kernel_release = uname.kernel_release
+ operating_system = uname.operating_system
+
+ lts = '-lts' if kernel_release.lower().endswith('-lts') else ''
+ if self.have_pacman is None:
+ self.have_pacman = True
+ try:
+ self.linux_installed = Pacman('linux-libre' + lts, True)
+ except:
+ self.have_linux_libre = False
+ try:
+ self.linux_installed = Pacman('linux' + lts, True)
+ except:
+ self.have_pacman = False
+ if self.have_pacman:
+ try:
+ self.linux_latest = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, False)
+ except:
+ self.have_pacman = None
+ elif self.have_pacman:
+ try:
+ self.linux_installed = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, True)
+ self.linux_latest = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, False)
+ except:
+ self.have_pacman = None
+
+ if (self.have_pacman is not None) and self.have_pacman:
+ linux_running = kernel_release.split('-')
+ linux_running, kernel_release = linux_running[:2], linux_running[2:]
+ linux_running = '-'.join(linux_running)
+ kernel_release = '-' + '-'.join(kernel_release)
+ self.linux_installed = self.linux_installed.version
+ self.linux_latest = self.linux_latest.version
+ if self.linux_installed == self.linux_latest:
+ if linux_running == self.linux_installed:
+ linux_running = '\033[32m%s\033[39m' % linux_running
+ else:
+ if linux_running == self.linux_installed:
+ linux_running = '\033[33m%s\033[39m' % linux_running
+ else:
+ linux_running = '\033[31m%s\033[39m' % linux_running
+ kernel_release = linux_running + kernel_release
+
+ rc = '%s %s %s'
+ rc %= (nodename, kernel_release, operating_system)
+ self.last_uname_read = rc
+ return rc
+
+ def function_users(self): ## TODO use inotify
+ users = Users('devfs').users
+ def colour_user(user):
+ if user == 'root': return '\033[31m%s\033[39m'
+ elif not user == self.you: return '\033[33m%s\033[39m'
+ else: return '%s'
+ users = ['%s{%i}' % (colour_user(u) % u, len(users[u])) for u in users.keys()]
+ users = 'Usr: %s' % (' '.join(users))
+ self.last_users_read = users
+ return users
+
+ def function_xdisplay(self):
+ if self.xdisplay is None:
+ x = XDisplay()
+ if x.connection is None:
+ self.xdisplay = 'No DISPLAY environment variable set'
+ self.xdisplay_detailed = self.xdisplay
+ else:
+ self.xdisplay = 'X: %s' % x.connection
+ self.xdisplay_detailed = 'Host: %s' % ('(localhost)' if x.host is None else x.host)
+ self.xdisplay_detailed += SEPARATOR
+ self.xdisplay_detailed += 'Display: %s' % (x.display)
+ if x.screen is not None:
+ self.xdisplay_detailed += SEPARATOR
+ self.xdisplay_detailed += 'Screen: %s' % (x.screen)
+ if x.vt is not None:
+ self.xdisplay += '%sVt: %i' % (SEPARATOR, x.vt)
+ self.xdisplay_detailed += '%sVt: %i' % (SEPARATOR, x.vt)
+ return self.xdisplay_detailed if self.show_detailed else self.xdisplay
+
+ def function_xkb(self): ## add update listener
+ xkb = XKB().get_locks()
+ kbd = 'Kbd:'
+ if self.num_lock:
+ kbd += ' \033[3%imnum\033[0m' % (1 if (xkb & XKB.NUM) == 0 else 2)
+ if self.cap_lock:
+ kbd += ' \033[3%imcap\033[0m' % (1 if (xkb & XKB.CAPS) == 0 else 2)
+ if self.scr_lock:
+ kbd += ' \033[3%imscr\033[0m' % (1 if (xkb & XKB.SCROLL) == 0 else 2)
+ return kbd
+
+ def function(self):
+ if self.display == 0:
+ return self.function_uname()
+ elif self.display == 1:
+ return self.function_users()
+ elif self.display == 2:
+ return self.function_xdisplay()
+ elif self.display == 3:
+ return self.function_xkb()
+
+
+class MyWeather(Entry):
+ def __init__(self, *args, stations = None, fahrenheit = False, wind = 'm/s', from_wind = False, visibility = 'km', **kwargs):
+ self.semaphore = threading.Semaphore()
+ self.stations = [MyWeather.get_metar_station()] if stations is None else [s.upper() for s in stations]
+ self.reports = [None] * len(self.stations)
+ self.up_to_date = [False] * len(self.stations)
+ self.in_deg_f = fahrenheit
+ self.wind_unit = wind
+ self.from_wind = from_wind
+ self.visibility_unit = visibility
+ self.show_temp = True
+ self.show_wind_speed = False
+ self.show_wind_gusts = False
+ self.show_wind_dir = False
+ self.show_wind_chill = False
+ self.show_humidity = False
+ self.show_dew = False
+ self.show_pressure = False
+ self.show_visibility = False
+ self.show_sky = False
+ self.show_station = False
+ self.station = 0
+ self.updated = False
+ self.segments = []
+ self.refresh = Sometimes(lambda : async(self.refresh_, name = 'weather'), 20 * 60 * 4)
+ self.refresh()
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == MIDDLE_BUTTON:
+ self.show_temp = True
+ self.show_wind_speed = True
+ self.show_wind_gusts = True
+ self.show_wind_dir = True
+ self.show_wind_chill = True
+ self.show_humidity = True
+ self.show_dew = True
+ self.show_pressure = True
+ self.show_visibility = True
+ self.show_sky = True
+ self.show_station = True
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ self.refresh.counter = 0
+ self.refresh()
+ elif button in (LEFT_BUTTON, SCROLL_UP, SCROLL_DOWN):
+ index = None
+ for i, seg in enumerate(self.segments):
+ if seg is None:
+ continue
+ (x, width) = seg
+ if 0 <= col - x < width:
+ index = i
+ break
+ if index is None:
+ return
+ if index == 0: # station
+ if button == LEFT_BUTTON:
+ self.show_station = False
+ elif button == SCROLL_UP:
+ station = self.station
+ if station + 1 < len(self.stations):
+ self.station = station + 1
+ else:
+ station = self.station
+ if station > 0:
+ self.station = station - 1
+ elif index == 1: # temperature
+ if button == LEFT_BUTTON:
+ self.show_temp = False
+ else:
+ self.in_deg_f = button == SCROLL_UP
+ elif index == 2: # wind speed/gusts
+ if button == LEFT_BUTTON:
+ if self.plusminus is None or col < self.plusminus:
+ self.show_wind_speed = False
+ else:
+ self.show_wind_gusts = False
+ else:
+ if self.wind_unit == 'm/s':
+ self.wind_unit = 'mph' if button == SCROLL_UP else 'm/s'
+ elif self.wind_unit == 'mph':
+ self.wind_unit = 'kn' if button == SCROLL_UP else 'm/s'
+ elif self.wind_unit in ('kn', 'kt', 'knot', 'knots'):
+ self.wind_unit = 'km/h' if button == SCROLL_UP else 'mph'
+ elif self.wind_unit in ('km/h', 'kmph'):
+ self.wind_unit = 'ft/s' if button == SCROLL_UP else 'kn'
+ elif self.wind_unit in ('ft/s', 'ftps'):
+ self.wind_unit = 'b' if button == SCROLL_UP else 'km/h'
+ else:
+ self.wind_unit = 'b' if button == SCROLL_UP else 'ft/s'
+ elif index == 3: # wind direction
+ if button == LEFT_BUTTON:
+ self.show_wind_dir = False
+ else:
+ self.from_wind = button == SCROLL_UP
+ elif index == 4: # wind chill
+ if button == LEFT_BUTTON:
+ self.show_wind_chill = False
+ else:
+ self.in_deg_f = button == SCROLL_UP
+ elif index == 5: # relative humidity
+ if button == LEFT_BUTTON:
+ self.show_humidity = False
+ else:
+ return
+ elif index == 6: # dew point
+ if button == LEFT_BUTTON:
+ self.show_dew = False
+ else:
+ self.in_deg_f = button == SCROLL_UP
+ elif index == 7: # pressure
+ if button == LEFT_BUTTON:
+ self.show_pressure = False
+ else:
+ return
+ elif index == 8: # visibility
+ if button == LEFT_BUTTON:
+ self.show_visibility = False
+ elif button == SCROLL_UP:
+ unit = self.visibility_unit
+ if unit in {'km' : 'm', 'm' : 'mi'}:
+ self.visibility_unit = {'km' : 'm', 'm' : 'mi'}[unit]
+ else:
+ unit = self.visibility_unit
+ if unit in {'mi' : 'm', 'mile' : 'm', 'm' : 'km'}:
+ self.visibility_unit = {'mi' : 'm', 'mile' : 'm', 'm' : 'km'}[unit]
+ elif index == 9: # sky conditions
+ if button == LEFT_BUTTON:
+ self.show_sky = False
+ else:
+ return
+ self.invalidate()
+
+ def refresh_(self):
+ if self.semaphore.acquire(blocking = False):
+ for index, station in enumerate(self.stations):
+ try:
+ self.reports[index] = Weather(station)
+ self.up_to_date[index] = True
+ except:
+ self.up_to_date[index] = False
+ self.semaphore.release()
+ self.invalidate()
+
+ def invalidate(self):
+ self.updated = False
+ Entry.invalidate(self)
+
+ def get_weather(self, index):
+ station = self.stations[index]
+ report = self.reports[index]
+ up_to_date = self.up_to_date[index]
+ station = station[0] + station[1:].lower()
+
+ if report is None:
+ if self.show_station:
+ return '%s: ?' % station
+ else:
+ return '?'
+
+ text = []
+
+ if self.show_temp and report.temp is not None:
+ value = report.temp
+ colour = '34'
+ if value < -10: colour = '39;44'
+ if value >= 18: colour = '39'
+ if value >= 25: colour = '33'
+ if value >= 30: colour = '31'
+ if self.in_deg_f:
+ value = value * 9 / 5 + 32
+ value = '\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C')
+ text.append(value)
+ else:
+ text.append(None)
+
+ if self.show_wind_speed and report.wind_speed is not None:
+ knot = report.wind_speed
+ kmph = knot * 1.852 # km/h
+ mps = kmph / 3.6 # m/s
+ mph = knot * 1.151 # mph
+ ftps = mps * 3.281 # ft/s
+ beaufort = (mps / 0.8365) ** (2 / 3) # B
+ if self.wind_unit in ('kn', 'kt', 'knot', 'knots'):
+ value, unit = knot, 'kn'
+ elif self.wind_unit in ('km/h', 'kmph'):
+ value, unit = kmph, 'km/h'
+ elif self.wind_unit == 'mph':
+ value, unit = mph, 'mph'
+ elif self.wind_unit in ('ft/s', 'ftps'):
+ value, unit = ftps, 'ft/s'
+ elif self.wind_unit.lower() in ('beaufort', 'beaufort scale', 'bf', 'bt', 'b'):
+ value, unit = beaufort, 'B'
+ else:
+ value, unit = mps, 'm/s'
+ beaufort = int(beaufort + 0.5)
+ colour = '32'
+ if beaufort >= 1: colour = '39'
+ if beaufort >= 3: colour = '32'
+ if beaufort >= 7: colour = '33'
+ if beaufort >= 10: colour = '31'
+ if beaufort >= 12: colour = '39;41'
+ wind = '\033[%sm%.0f\033[0m' % (colour, value)
+ if self.show_wind_gusts and report.wind_gusts is not None:
+ knot = report.wind_gusts
+ kmph = knot * 1.852 # km/h
+ mps = kmph / 3.6 # m/s
+ mph = knot * 1.151 # mph
+ ftps = mps * 3.281 # ft/s
+ beaufort = (mps / 0.8365) ** (2 / 3) # B
+ if self.wind_unit in ('kn', 'kt', 'knot', 'knots'):
+ value = knot
+ elif self.wind_unit in ('km/h', 'kmph'):
+ value = kmph
+ elif self.wind_unit == 'mph':
+ value = mph
+ elif self.wind_unit in ('ft/s', 'ftps'):
+ value = ftps
+ elif self.wind_unit.lower() in ('beaufort', 'beaufort scale', 'bf', 'bt', 'b'):
+ value = beaufort
+ else:
+ value = mps
+ beaufort = int(beaufort + 0.5)
+ colour = '32'
+ if beaufort >= 1: colour = '39'
+ if beaufort >= 3: colour = '32'
+ if beaufort >= 7: colour = '33'
+ if beaufort >= 10: colour = '31'
+ if beaufort >= 12: colour = '39;41'
+ wind += '±\033[%sm%.0f\033[0m' % (colour, value)
+ wind += unit
+ text.append(wind)
+ else:
+ text.append(None)
+
+ def wind_dir(direction):
+ if not self.from_wind:
+ direction += 180
+ direction %= 360
+ if direction < 0:
+ direction += 360
+ if (direction < 90):
+ if direction == 0:
+ return 'N'
+ if direction <= 45:
+ return 'N%.0f°E' % direction
+ return 'E%.0f°N' % (90 - direction)
+ elif (90 <= direction < 180):
+ if direction == 0:
+ return 'E'
+ direction -= 90
+ if direction <= 45:
+ return 'E%.0f°S' % direction
+ return 'S%.0f°E' % (90 - direction)
+ elif (180 <= direction < 270):
+ if direction == 0:
+ return 'S'
+ direction -= 180
+ if direction <= 45:
+ return 'S%.0f°W' % direction
+ return 'W%.0f°S' % (90 - direction)
+ else:
+ if direction == 0:
+ return 'W'
+ direction -= 270
+ if direction <= 45:
+ return 'W%.0f°N' % direction
+ return 'N%.0f°W' % (90 - direction)
+ if not self.show_wind_dir:
+ wind = None
+ elif report.wind_var is not None:
+ wind = wind_dir(report.wind_var[0]) + '-' + wind_dir(report.wind_var[1])
+ elif report.wind_dir is not None:
+ wind = wind_dir(report.wind_dir)
+ else:
+ wind = None
+ if wind is not None:
+ if self.from_wind:
+ wind += '→'
+ else:
+ wind = '→' + wind
+ text.append(wind)
+ else:
+ text.append(None)
+
+ if self.show_wind_chill and report.wind_chill is not None:
+ value = report.wind_chill
+ # Coloured by frostbite time, however the wind is not taken
+ # into account so the colour is approximate
+ colour = '39'
+ if value <= -28: colour = '33'
+ if value <= -37: colour = '31'
+ if value <= -46: colour = '39;41'
+ if self.in_deg_f:
+ value = value * 9 / 5 + 32
+ value = 'w\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C')
+ text.append(value)
+ else:
+ text.append(None)
+
+ if self.show_humidity and report.humidity is not None:
+ value = report.humidity
+ colour = '34'
+ if value >= 26: colour = '32'
+ if value >= 31: colour = '39'
+ if value >= 37: colour = '33'
+ if value >= 52: colour = '31'
+ if value >= 73: colour = '39;41'
+ value = '\033[%sm%.0f\033[0m%%' % (colour, value)
+ text.append(value)
+ else:
+ text.append(None)
+
+ if self.show_dew and report.dew is not None:
+ value = report.dew
+ colour = '34'
+ if value >= 10: colour = '32'
+ if value >= 13: colour = '39'
+ if value >= 16: colour = '33'
+ if value >= 21: colour = '31'
+ if value >= 26: colour = '39;41'
+ if self.in_deg_f:
+ value = value * 9 / 5 + 32
+ value = 'd\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C')
+ text.append(value)
+ else:
+ text.append(None)
+
+ if self.show_pressure and report.pressure is not None:
+ text.append('%.0fhPa' % report.pressure)
+ else:
+ text.append(None)
+
+ if self.show_visibility and report.visibility is not None:
+ mile = report.visibility
+ km = mile * 1.609344
+ m = mile * 1609.344
+ if self.visibility_unit in ('mile', 'mi'):
+ value, unit = mile, 'mi'
+ elif self.visibility_unit == 'm':
+ value, unit = m, 'm'
+ else:
+ value, unit = km, 'km'
+ text.append('%.0f%s' % (value, unit))
+ else:
+ text.append(None)
+
+ if self.show_sky and 'Sky conditions' in report.fields:
+ value = report.fields['Sky conditions']
+ if not value == '':
+ text.append(value)
+ else:
+ text.append(None)
+ else:
+ text.append(None)
+
+ segments = []
+ x = 0
+ if self.show_station:
+ w = len(station)
+ segments.append((x, w))
+ x += w + 2
+ else:
+ segments.append(None)
+ x -= 1
+ self.plusminus = None
+ for i, segment in enumerate(text):
+ if segment is None:
+ segments.append(None)
+ else:
+ if i == 1 and '±' in segment:
+ self.plusminus = x + Bar.coloured_length(segment.split('±')[0])
+ w = Bar.coloured_length(segment)
+ x += 1
+ segments.append((x, w))
+ x += w
+ self.segments = segments
+ text = [s for s in text if s is not None]
+
+ if len(text) == 0:
+ return station
+
+ if not up_to_date:
+ if len(text) <= 1:
+ text = ' '.join(text) + '?'
+ else:
+ text = ' '.join(text) + ' ?'
+ else:
+ text = ' '.join(text)
+ if self.show_station:
+ text = '%s: %s' % (station, text)
+ return text
+
+ def function(self):
+ if not self.updated:
+ self.updated = True
+ self.text = self.get_weather(self.station)
+ rc = self.text
+ self.refresh()
+ return rc
+
+ @staticmethod
+ def get_metar_station():
+ try:
+ with open(HOME + '/.config/metar', 'rb') as file:
+ station = file.read()
+ except:
+ try:
+ with open('/etc/metar', 'rb') as file:
+ station = file.read()
+ except:
+ print('~/.config/metar is not set', file = sys.stderr, flush = True)
+ station = b'ESSA'
+ return station.decode('utf-8', 'strict').split('\n')[0].upper()
+
+
+class MyNews(Entry):
+ def __init__(self, *args, status_path = None, **kwargs):
+ if status_path is not None:
+ self.status_path = status_path
+ else:
+ self.status_path = HOME + '/.var/lib/featherweight/status'
+ self.get_news()
+ Entry.__init__(self, *args, **kwargs)
+ async(self.refresh, name = 'news')
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ async(lambda : subprocess.Popen([TERMINAL, '-e', 'featherweight']).wait())
+ elif button == RIGHT_BUTTON:
+ async(lambda : subprocess.Popen(['featherweight', '--update', '--system']).wait())
+
+ def get_news(self):
+ try:
+ with open(self.status_path, 'rb') as file:
+ status = int(file.read().decode('utf-8', 'replace').replace('\n', ''))
+ except:
+ status = 0
+ colour = '31'
+ if status <= 0: colour = '0'
+ elif status <= 5: colour = '32'
+ elif status <= 10: colour = '33'
+ self.text = 'News: \033[%sm%i\033[0m' % (colour, status)
+
+ def refresh(self):
+ while True:
+ try:
+ spawn_read(*pdeath('HUP', 'inotifywait', self.status_path, '-e', 'close_write'))
+ self.get_news()
+ except:
+ time.sleep(1)
+
+ def function(self):
+ return self.text
+
+
+class MyALSA(Entry):
+ def __init__(self, *args, timeout = None, sleep = None, mixers = None, **kwargs):
+ if timeout is not None:
+ self.timeout = timeout
+ else:
+ self.timeout = 5
+ if sleep is not None:
+ self.sleep = sleep
+ else:
+ self.sleep = 5
+ if mixers is not None:
+ mixers = mixers
+ else:
+ mixers = ('Master', 'PCM')
+ self.alsa = []
+ for mixer in mixers:
+ try:
+ self.alsa.append(ALSA(mixername = mixer))
+ except:
+ pass
+ try:
+ import posix_ipc
+ method = 0
+ except:
+ method = 2
+ try:
+ path = os.environ['PATH'].split(':')
+ for p in path:
+ p += '/cmdipc'
+ if os.access(p, os.F_OK | os.X_OK, effective_ids = True):
+ method = 1
+ break
+ except:
+ pass
+ self.sep_width = Bar.coloured_length(SEPARATOR)
+ self.get_volume()
+ Entry.__init__(self, *args, **kwargs)
+ async((self.refresh_posix_ipc, self.refresh_cmdipc, self.refresh_wait)[method], name = 'alsa')
+
+ def action(self, col, button, x, y):
+ mixer = 0
+ mixer_text = self.text.split(SEPARATOR)
+ while mixer < len(mixer_text): ## the limit is just a precaution
+ mixer_width = Bar.coloured_length(mixer_text[mixer])
+ if col >= mixer_width:
+ col -= mixer_width
+ if col < self.sep_width:
+ return
+ col -= self.sep_width
+ else:
+ break
+ mixer += 1
+ mixer_text = mixer_text[mixer]
+
+ channel = -1
+ mixer_text = mixer_text.split(': ')
+ mixer_label = ': '.join(mixer_text[:-1]) + ': '
+ mixer_text = mixer_text[-1].split(' ')
+ mixer_label = Bar.coloured_length(mixer_label)
+ if col >= mixer_label:
+ col -= mixer_label
+ while channel < len(mixer_text): ## the limit is just a precaution
+ channel += 1
+ channel_width = Bar.coloured_length(mixer_text[channel])
+ if col < channel_width:
+ break
+ col -= channel_width
+ if col < 1:
+ channel = -1
+ break
+ col -= 1
+
+ mixer = self.alsa[mixer]
+ if button == LEFT_BUTTON:
+ muted = mixer.get_mute()
+ muted = not (any(muted) if channel == -1 else muted[channel])
+ mixer.set_mute(muted, channel)
+ elif button == RIGHT_BUTTON:
+ volume = mixer.get_volume()
+ volume = limited(sum(volume) / len(volume))
+ mixer.set_volume(volume, -1)
+ elif button in (SCROLL_UP, SCROLL_DOWN):
+ volume = mixer.get_volume()
+ adj = -5 if button == SCROLL_DOWN else 5
+ if channel < 0:
+ for ch in range(len(volume)):
+ mixer.set_volume(limited(volume[ch] + adj), ch)
+ else:
+ mixer.set_volume(limited(volume[channel] + adj), channel)
+ else:
+ return
+ self.get_volume()
+ self.invalidate()
+
+ def get_volume(self):
+ text_v = lambda v : '--%' if v is None else ('%2i%%' % v)[:3]
+ read_m = lambda m : '%s: %s' % (m.mixername, ' '.join(text_v(v) for v in m.get_volume()))
+ self.text = SEPARATOR.join(read_m(m) for m in self.alsa)
+
+ def refresh_posix_ipc(self):
+ import posix_ipc
+ s = posix_ipc.Semaphore('/.xpybar.alsa.0', posix_ipc.O_CREAT, 0o600, 1)
+ c = posix_ipc.Semaphore('/.xpybar.alsa.1', posix_ipc.O_CREAT, 0o600, 0)
+ q = posix_ipc.Semaphore('/.xpybar.alsa.2', posix_ipc.O_CREAT, 0o600, 0)
+ while True:
+ try:
+ s.release() ; c.release()
+ try:
+ q.acquire(timeout)
+ except posix_ipc.BusyError:
+ pass
+ c.acquire(None)
+ s.acquire(None)
+ self.get_volume()
+ except:
+ time.sleep(self.sleep)
+
+ def refresh_cmdipc(self):
+ command = pdeath('HUP', 'cmdipc', '-PCck', '/.xpybar.alsa.0/.xpybar.alsa.1/.xpybar.alsa.2', 'wait', '-b%i' % self.timeout)
+ while True:
+ try:
+ spawn_read(*command)
+ self.get_volume()
+ except:
+ time.sleep(self.sleep)
+
+ def refresh_wait(self):
+ while True:
+ try:
+ time.sleep(self.sleep)
+ self.get_volume()
+ except:
+ pass
+
+ def function(self):
+ return self.text
+
+
+class MyBattery(Entry):
+ def __init__(self, *args, **kwargs):
+ self.show_all = False
+ self.show_battery = 0
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.show_all = not self.show_all
+ self.invalidate()
+ elif button == SCROLL_UP:
+ self.show_battery += 1
+ self.invalidate()
+ elif button == SCROLL_DOWN:
+ self.show_battery -= 1
+ if self.show_battery < 0:
+ self.show_battery = 0
+ self.invalidate()
+
+ def colourise_(self, text):
+ try:
+ value = text.replace(',', '.')
+ value = float(value) if '.' in value else int(value)
+ colour = '39'
+ if value < 80: colour = '32'
+ if value < 50: colour = '33'
+ if value < 15: colour = '31'
+ if value < 5: colour = '7;31'
+ return '\033[%sm%s\033[0m' % (colour, text)
+ except:
+ return text
+
+ def colourise(self, text):
+ buf = []
+ state = None
+ for c in reversed(text):
+ if c == '\t':
+ c = ' '
+ if state is not None:
+ if c == ' ':
+ if state == '':
+ buf.append(c)
+ continue
+ buf.append(self.colourise_(state))
+ buf.append(c)
+ state = None
+ else:
+ state = c + state
+ elif c == '%':
+ buf.append(c)
+ state = ''
+ else:
+ buf.append(c)
+ if state is not None and state != '':
+ buf.append(self.colourise_(state))
+ return ''.join(reversed(buf))
+
+ def function(self):
+ try:
+ data = spawn_read('acpi').split('\n')
+ except:
+ return 'acpi missing'
+ if self.show_battery >= len(data):
+ self.show_battery = len(data) - 1
+ if len(data) == 1:
+ return self.colourise(': '.join(data[0].split(': ')[1:]))
+ if self.show_all:
+ data = [self.colourise(': '.join(datum.split(': ')[1:])) for datum in data]
+ data = SEPARATOR.join('Bat%i: %s' % (i, datum) for i, datum in enumerate(data))
+ return data
+ data = data[self.show_battery]
+ data = ': '.join(data.split(': ')[1:])
+ data = 'Bat%i: %s' % (self.show_battery, self.colourise(data))
+ return data
+
+
+class MyCPU(Entry):
+ def __init__(self, *args, **kwargs):
+ self.last_sirq_split = SoftIRQs()
+ cpu = CPU()
+ self.last_time = time.monotonic()
+ self.last_cpu_stat = cpu.cpu
+ self.last_cpu_total = sum(cpu.cpu)
+ self.last_cpus_total = [sum(c) for c in cpu.cpus]
+ self.last_cpus_stat = [[c[s] for c in cpu.cpus] for s in range(len(cpu.cpu))]
+ self.last_intr = cpu.intr_total
+ self.last_ctxt = cpu.ctxt
+ self.last_fork = cpu.processes
+ self.last_sirq = cpu.softirq_total
+ self.none = self.colourise(None)
+ self.coloured = tuple(self.colourise(i) for i in range(101))
+ self.show_all = False
+ self.show_function = 0
+ self.functions = [ lambda *v : self.function_cpu(CPU.idle, '', *v)
+ , self.function_intr
+ , self.function_ctxt
+ , self.function_fork
+ , self.function_proc
+ , self.function_sirq
+ ]
+ for key in self.last_sirq_split.keys:
+ make = lambda key : (lambda *v : self.function_sirq_split(key, *v))
+ self.functions.append(make(key))
+ self.functions += [ lambda *v : self.function_cpu(CPU.user, '(user)', *v)
+ , lambda *v : self.function_cpu(CPU.nice, '(nice)', *v)
+ , lambda *v : self.function_cpu(CPU.system, '(system)', *v)
+ , lambda *v : self.function_cpu(CPU.iowait, '(iowait)', *v)
+ , lambda *v : self.function_cpu(CPU.irq, '(irq)', *v)
+ , lambda *v : self.function_cpu(CPU.softirq, '(softirq)', *v)
+ , lambda *v : self.function_cpu(CPU.steal, '(steal)', *v)
+ , lambda *v : self.function_cpu(CPU.guest, '(guest)', *v)
+ , lambda *v : self.function_cpu(CPU.guest_nice, '(guest nice)', *v)
+ , self.function_load
+ , self.function_task
+ , self.function_pid
+ , self.function_online
+ ]
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.show_all = not self.show_all
+ self.invalidate()
+ elif button == SCROLL_UP:
+ n = self.show_function + 1
+ if n < len(self.functions):
+ self.show_function = n
+ self.invalidate()
+ elif button == SCROLL_DOWN:
+ n = self.show_function - 1
+ if n >= 0:
+ self.show_function = n
+ self.invalidate()
+
+ def usage(self, now_stat, now_total, last_stat, last_total, idle):
+ total = now_total - last_total
+ stat = now_stat - last_stat
+ return None if total == 0 else (total - stat if idle else stat) * 100 / total
+
+ def colourise_(self, value):
+ if value is None:
+ return self.none
+ else:
+ return self.coloured[limited(value)]
+
+ def colourise(self, value):
+ if value is None:
+ return '--%'
+ elif value >= 100:
+ return '\033[31m100\033[0m'
+ colour = '39'
+ if value >= 5: colour = '32'
+ if value >= 50: colour = '33'
+ if value >= 90: colour = '31'
+ return '\033[%sm%2i\033[0m%%' % (colour, value)
+
+ def function_cpu(self, stat, name, cpu, display, tdiff):
+ now_cpu_stat = self.now_cpu_stat[stat]
+ now_cpus_stat = self.now_cpus_stat[stat]
+ last_cpus_stat = self.last_cpus_stat[stat]
+ last_cpu_stat = self.last_cpu_stat[stat]
+
+ if display:
+ cpu = (now_cpu_stat, self.now_cpu_total, last_cpu_stat, self.last_cpu_total)
+ cpu = self.colourise_(self.usage(*cpu, idle = stat == CPU.idle))
+ if self.show_all:
+ cpus = (now_cpus_stat, self.now_cpus_total, last_cpus_stat, self.last_cpus_total)
+ cpus = ' '.join(self.colourise_(self.usage(*c, idle = stat == CPU.idle)) for c in zip(*cpus))
+ cpu = 'Cpu%s: %s : %s' % (name, cpus, cpu)
+ else:
+ cpu = 'Cpu%s: %s' % (name, cpu)
+
+ return cpu
+
+ def function_intr(self, cpu, display, tdiff):
+ now_intr = cpu.intr_total
+ if display:
+ cpu = 'Intr: %.0fHz' % ((now_intr - self.last_intr) / tdiff)
+ self.last_intr = now_intr
+ return cpu
+
+ def function_ctxt(self, cpu, display, tdiff):
+ now_ctxt = cpu.ctxt
+ if display:
+ cpu = 'Ctxt: %.0fHz' % ((now_ctxt - self.last_ctxt) / tdiff)
+ self.last_ctxt = now_ctxt
+ return cpu
+
+ def function_fork(self, cpu, display, tdiff):
+ now_fork = cpu.processes
+ if display:
+ cpu = 'Fork: %.0fHz' % ((now_fork - self.last_fork) / tdiff)
+ self.last_fork = now_fork
+ return cpu
+
+ def function_sirq(self, cpu, display, tdiff):
+ now_sirq = cpu.softirq_total
+ if display:
+ cpu = 'Sirq: %.0fHz' % ((now_sirq - self.last_sirq) / tdiff)
+ self.last_sirq = now_sirq
+ return cpu
+
+ def function_proc(self, cpu, display, tdiff):
+ if display:
+ cpu = 'Proc: %irun %iio' % (cpu.procs_running, cpu.procs_blocked)
+ return cpu
+
+ def function_load(self, cpu, display, tdiff):
+ if display:
+ load = AverageLoad()
+ cpu = 'Load: %.2f %.2f %.2f' % (load.total_avg_5_min, load.total_avg_10_min, load.total_avg_15_min)
+ return cpu
+
+ def function_task(self, cpu, display, tdiff):
+ if display:
+ load = AverageLoad()
+ cpu = 'Task: %i/%i (%.0f%%)' % (load.active_tasks, load.total_tasks, load.active_tasks * 100 / load.total_tasks)
+ return cpu
+
+ def function_pid(self, cpu, display, tdiff):
+ if display:
+ load = AverageLoad()
+ cpu = 'Last PID: %i' % load.last_pid
+ return cpu
+
+ def function_online(self, cpu, display, tdiff):
+ if display:
+ try:
+ cpu, cpuonline, on, off = '', CPUOnline(), 0, 0
+ online, offline = cpuonline.online, cpuonline.offline
+ while on < len(online) and off < len(offline):
+ if online[on] < offline[off]:
+ cpu += ' \033[32m%s\033[0m' % online[on]
+ on += 1
+ else:
+ cpu += ' \033[31m%s\033[0m' % offline[off]
+ off += 1
+ cpu += ''.join(' \033[32m%s\033[0m' % c for c in online[on:])
+ cpu += ''.join(' \033[31m%s\033[0m' % c for c in offline[off:])
+ cpu = 'Online:%s' % cpu
+ except Exception as e:
+ cpu = str(e)
+ return cpu
+
+ def function_sirq_split(self, key, cpu, display, tdiff):
+ if display:
+ label = 'Sirq(%s)' % key.lower().replace('_', ' ').replace(' rx', '↓').replace(' tx', '↑')
+ now = self.now_sirq_split[key]
+ last = self.last_sirq_split[key]
+ hz = lambda n, l : '%0.fHz' % ((n - l) / tdiff)
+ n = len(now)
+ snow, slast = sum(now), sum(last)
+ anow, alast = snow / n, slast / n
+ each = ''
+ if self.show_all:
+ each = '%s : ' % ' '.join(hz(n, l) for n, l in zip(now, last))
+ else:
+ each = ''
+ cpu = '%s: %s%s(%s)' % (label, each, hz(snow, slast), hz(anow, alast))
+ return cpu
+
+ def function(self):
+ now = time.monotonic()
+ cpu = CPU()
+ self.now_sirq_split = SoftIRQs()
+ tdiff = now - self.last_time
+ self.last_time = now
+ display = self.show_function
+ self.now_cpu_stat = cpu.cpu
+ self.now_cpu_total = sum(cpu.cpu)
+ self.now_cpus_total = [sum(c) for c in cpu.cpus]
+ self.now_cpus_stat = [[c[s] for c in cpu.cpus] for s in range(len(cpu.cpu))]
+ for i in range(len(self.functions)):
+ if i == display:
+ ret = self.functions[i](cpu, True, tdiff)
+ else:
+ self.functions[i](cpu, False, tdiff)
+ self.last_cpus_stat = self.now_cpus_stat
+ self.last_cpu_stat = self.now_cpu_stat
+ self.last_cpus_total = self.now_cpus_total
+ self.last_cpu_total = self.now_cpu_total
+ self.last_sirq_split = self.now_sirq_split
+ return ret
+
+
+class MyMemory(Entry):
+ def __init__(self, *args, **kwargs):
+ self.coloured = tuple(self.colourise(i) for i in range(101))
+ self.show_labels = False
+ self.show_value = -1
+ self.show_default = False
+ self.show_swaps = False
+ self.show_swap = 0
+ self.labels = list(sorted(Memory().keys))
+ swaps = Swaps()
+ self.prio = swaps.header_map['Priority']
+ self.used = swaps.header_map['Used']
+ self.size = swaps.header_map['Size']
+ self.swap = swaps.header_map['Filename']
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ if self.show_value >= 0:
+ self.show_default = not self.show_default
+ self.invalidate()
+ elif button == MIDDLE_BUTTON:
+ self.show_labels = not self.show_labels
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ self.show_swaps = not self.show_swaps
+ self.invalidate()
+ elif button == SCROLL_UP:
+ if self.show_swaps:
+ self.show_swap += 1
+ self.invalidate()
+ else:
+ n = self.show_value + 1
+ if n < len(self.labels):
+ self.show_value = n
+ self.invalidate()
+ elif button == SCROLL_DOWN:
+ if self.show_swaps:
+ n = self.show_swap
+ if n > 0:
+ self.show_swap = n - 1
+ self.invalidate()
+ else:
+ self.show_value -= 1
+ if self.show_value < -1:
+ self.show_value = -1
+ self.invalidate()
+
+ def u(self, value):
+ units = 'KMGTPE'
+ unit = 0
+ while unit + 1 < len(units) and value >= 1024:
+ unit += 1
+ value /= 1024
+ return '%.1f%s' % (value, units[unit])
+
+ def colourise(self, value):
+ if value >= 100:
+ return '\033[31m100\033[0m'
+ colour = '39'
+ if value > 30: colour = '32'
+ if value > 50: colour = '33'
+ if value > 80: colour = '31'
+ return '\033[%sm%i\033[0m%%' % (colour, value)
+
+ def function(self):
+ if self.show_swaps:
+ swaps = Swaps()
+ while True:
+ if len(swaps.swaps) == 0:
+ return 'no swaps available'
+ try:
+ swap = swaps.swaps[self.show_swap]
+ used, size = int(swap[self.used]), int(swap[self.size])
+ swap, prio = swap[self.swap], int(swap[self.prio])
+ return '%s: %s (%sB/%sB, prio %i)' % (swap, self.colourise(used * 100 / size),
+ self.u(used), self.u(size), prio)
+ except:
+ self.show_swap -= 1
+ if self.show_swap < 0:
+ self.show_swaps = False
+ return self.function()
+ else:
+ memory = Memory()
+ if not self.show_default and self.show_value > 0:
+ label = self.labels[self.show_value]
+ try:
+ value = memory[label]
+ unit = 0
+ units = ['K', 'M', 'G', 'T', 'P', 'E']
+ while (unit + 1 < len(units)) and (value >= 1024):
+ value /= 1024
+ unit += 1
+ return '%s: %.1f%sB' % (label, value, units[unit])
+ except:
+ self.show_value = -1
+ if memory.mem_total == 0:
+ mem = '---'
+ shm = '---'
+ else:
+ mem = self.coloured[limited(memory.mem_used * 100 / memory.mem_total)]
+ shm = self.coloured[limited(memory.shmem * 100 / memory.mem_total)]
+ if memory.swap_total == 0:
+ swp = 'n/a'
+ else:
+ swp = self.coloured[limited(memory.swap_used * 100 / memory.swap_total)]
+ if self.show_labels:
+ mem = 'Mem: %s%sSwp: %s%sShm: %s' % (mem, SEPARATOR, swp, SEPARATOR, shm)
+ else:
+ mem = 'Mem: %s %s %s' % (mem, swp, shm)
+ return mem
+
+
+class MyStat(Entry):
+ def __init__(self, *args, **kwargs):
+ self.keys_4 = SNMP().keys
+ self.keys_6 = SNMP6().keys
+ self.keys_vm = VMStat().keys
+ self.show_group = 0
+ self.show_value_4 = 0
+ self.show_value_6 = 0
+ self.show_value_vm = 0
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ n = self.show_group + 1
+ if n < 4:
+ self.show_group = n
+ self.invalidate()
+ elif button == MIDDLE_BUTTON:
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ n = self.show_group
+ if n > 0:
+ self.show_group = n - 1
+ self.invalidate()
+ elif button == SCROLL_UP:
+ if self.show_group == 0:
+ n = self.show_value_4
+ if n + 1 < len(self.keys_4):
+ self.show_value_4 = n + 1
+ self.invalidate()
+ elif self.show_group == 1:
+ n = self.show_value_6
+ if n + 1 < len(self.keys_6):
+ self.show_value_6 = n + 1
+ self.invalidate()
+ elif self.show_group == 2:
+ n = self.show_value_vm
+ if n + 1 < len(self.keys_vm):
+ self.show_value_vm = n + 1
+ self.invalidate()
+ elif self.show_group == 3:
+ pass
+ elif button == SCROLL_DOWN:
+ if self.show_group == 0:
+ n = self.show_value_4
+ if n > 0:
+ self.show_value_4 = n - 1
+ self.invalidate()
+ elif self.show_group == 1:
+ n = self.show_value_6
+ if n > 0:
+ self.show_value_6 = n - 1
+ self.invalidate()
+ elif self.show_group == 2:
+ n = self.show_value_vm
+ if n > 0:
+ self.show_value_vm = n - 1
+ self.invalidate()
+ elif self.show_group == 3:
+ pass
+
+ def function(self):
+ try:
+ if self.show_group == 0:
+ label = self.keys_4[self.show_value_4]
+ value = SNMP()[label]
+ elif self.show_group == 1:
+ label = self.keys_6[self.show_value_6]
+ value = SNMP6()[label]
+ elif self.show_group == 2:
+ label = self.keys_vm[self.show_value_vm]
+ value = VMStat()[label]
+ label = ''.join(w[:1].upper() + w[1:] for w in label.split('_'))
+ elif self.show_group == 3:
+ uptime = Uptime()
+ avg = uptime.uptime_seconds - uptime.average_idle_seconds
+ wrk = (avg) * 100 / uptime.uptime_seconds
+ up = '%id%i:%02i' % uptime.uptime[:3]
+ avg = '%id%i:%02i' % Uptime.split_time(avg)[:3]
+ return 'Uptime: %.0f%% %s / %s' % (wrk, avg, up)
+ return '%s: %i' % (label, value)
+ except Exception as e:
+ return str(e)
+
+
+class MyNetwork(Entry):
+ def __init__(self, *args, limits = None, ignore = None, pings = None, **kwargs):
+ self.limits = { 'rx_bytes' : None # Download speed in bytes (not bits)
+ , 'tx_bytes' : None # Upload speed in bytes (not bits)
+ , 'rx_total' : None # Download cap in bytes
+ , 'tx_total' : None # Upload cap in bytes
+ }
+ if limits is not None:
+ self.limits = limits
+ if pings is None:
+ pings = ['gateway']
+ elif isinstance(pings, str) or isinstance(pings, Ping):
+ pings = [pings]
+ pings = [(Ping(targets = Ping.get_nics(p)) if isinstance(p, str) else p).monitors for p in pings]
+ self.pings = {}
+ for ping in pings:
+ for nic in ping.keys():
+ if nic not in self.pings:
+ self.pings[nic] = ping[nic]
+ else:
+ self.pings[nic] += ping[nic]
+ self.ignore = ['lo'] if ignore is None else ignore
+ self.net_time = time.monotonic()
+ self.net_last = {}
+ self.show_all = False
+ self.show_name = False
+ self.show_value = 0
+ self.labels = ['bytes', 'total', 'packets', 'errs',
+ 'drop', 'fifo', 'frame', 'colls',
+ 'carrier', 'compressed', 'multicast']
+ self.in_bytes = False # in bits if showing total
+ Entry.__init__(self, *args, **kwargs)
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.show_all = not self.show_all
+ elif button == MIDDLE_BUTTON:
+ self.show_name = not self.show_name
+ elif button == RIGHT_BUTTON:
+ self.in_bytes = not self.in_bytes
+ elif button == SCROLL_UP:
+ n = self.show_value + 1
+ if n >= len(self.labels):
+ return
+ self.show_value = n
+ elif button == SCROLL_DOWN:
+ n = self.show_value - 1
+ if self.show_value < 0:
+ return
+ self.show_value = n
+ else:
+ return
+ self.invalidate()
+
+ def colourise(self, value, percent):
+ colour = '39'
+ if percent > 25: colour = '32'
+ if percent > 50: colour = '33'
+ if percent > 90: colour = '31'
+ return '\033[%sm%3.0f\033[0m' % (colour, value)
+
+ def KBps(self, network, device, direction, net_tdiff):
+ direction += '_bytes'
+ value = network[device][direction]
+ limit = None
+ if direction in self.limits:
+ limit = self.limits[direction]
+ if limit is None:
+ limit = 12500000 # 100 mbps
+ if device in self.net_last:
+ value -= self.net_last[device][direction]
+ else:
+ value = 0
+ percent = value * 100 / (limit * net_tdiff)
+ value /= 1024 * net_tdiff
+ return self.colourise(value, percent)
+
+ def kbps(self, network, device, direction, net_tdiff):
+ direction += '_bytes'
+ value = network[device][direction]
+ limit = None
+ if direction in self.limits:
+ limit = self.limits[direction]
+ if limit is None:
+ limit = 12500000 # 100 mbps
+ if device in self.net_last:
+ value -= self.net_last[device][direction]
+ else:
+ value = 0
+ percent = value * 100 / (limit * net_tdiff)
+ value /= 128 * net_tdiff
+ return self.colourise(value, percent)
+
+ def total(self, network, device, direction, bits):
+ direction += '_bytes'
+ value = network[device][direction]
+ limit = self.limits[direction] if direction in self.limits else None
+ if limit is not None:
+ percent = value * 100 / limit
+ colour = '32'
+ if percent >= 25: colour = '39'
+ if percent >= 50: colour = '33'
+ if percent >= 75: colour = '31'
+ if percent >= 95: colour = '7;33'
+ if percent >= 100: colour = '7;31'
+ else:
+ colour = '39'
+ if bits:
+ value *= 8
+ unit = 0
+ if bits:
+ units = ['', 'k', 'm', 'g', 't', 'p', 'e']
+ else:
+ units = ['', 'K', 'M', 'G', 'T', 'P', 'E']
+ while (unit + 1 < len(units)) and (value >= 1024):
+ value /= 1024
+ unit += 1
+ return '\033[%sm%.1f\033[0m%s' % (colour, value, units[unit])
+
+ def ping(self, monitor):
+ monitor.semaphore.acquire()
+ try:
+ latency = monitor.get_latency(True)[1]
+ droptime = monitor.dropped_time(True)
+ if droptime:
+ return ' \033[31m%4is\033[00m' % droptime
+ elif latency is None:
+ return ' \033[31mdrop?\033[00m'
+ colour = '31'
+ if latency < 5: colour = '32'
+ elif latency < 10: colour = '39'
+ elif latency < 20: colour = '33'
+ return ' \033[%sm%5.2f\033[00m' % (colour, latency)
+ finally:
+ monitor.semaphore.release()
+
+ def function(self):
+ net_now = time.monotonic()
+ net_tdiff, self.net_time = net_now - self.net_time, net_now
+ network = Network(*self.ignore).devices
+ label = self.labels[self.show_value]
+ show_total = label == 'total'
+ show_bytes = label == 'bytes'
+ xlabel = 'bytes' if show_total else label
+ suffix = ''
+ if show_total and self.in_bytes:
+ f = lambda dev, dir : self.total(network, dev, dir, True) + 'b'
+ elif show_total:
+ f = lambda dev, dir : self.total(network, dev, dir, False) + 'B'
+ elif show_bytes and self.in_bytes:
+ f = lambda dev, dir : self.KBps(network, dev, dir, net_tdiff) + 'KB/s'
+ elif show_bytes:
+ f = lambda dev, dir : self.kbps(network, dev, dir, net_tdiff) + 'kbps'
+ else:
+ f = lambda dev, dir : '%i' % network[dev][dir + '_' + label]
+ suffix = ' ' + label
+ def create(lbl, dev):
+ ret = ''
+ if lbl is not None:
+ ret += lbl + ': '
+ have_down = ('rx_' + xlabel) in network[dev]
+ have_up = ('tx_' + xlabel) in network[dev]
+ if have_down:
+ ret += f(dev, 'rx') + '↓'
+ if have_up:
+ ret += ' '
+ if have_up:
+ ret += f(dev, 'tx') + '↑'
+ ret += suffix
+ if show_bytes or show_total:
+ if dev == '*':
+ for dev in self.pings.keys():
+ for ping in self.pings[dev]:
+ ret += self.ping(ping)
+ elif dev in self.pings:
+ for ping in self.pings[dev]:
+ ret += self.ping(ping)
+ return ret
+ if self.show_all:
+ if self.show_name:
+ net = [create(dev, dev) for dev in network]
+ else:
+ net = [create(None, dev) for dev in network]
+ net = (SEPARATOR if self.show_name else ' ').join(net)
+ else:
+ devsum = {}
+ for dev in network.keys():
+ table = network[dev]
+ for key in table.keys():
+ if key not in devsum:
+ devsum[key] = 0
+ devsum[key] += table[key]
+ network['*'] = devsum
+ if self.show_name:
+ net = create('Net', '*')
+ else:
+ net = create(None, '*')
+ self.net_last = network
+ return net
+
+
+class MyIO(Entry):
+ def __init__(self, *args, fs_name_map = None, fs_ignore = None, fs_type_ignore = None, **kwargs):
+ self.fs_name_map = [] if fs_name_map is None else fs_name_map
+ self.fs_ignore = set([] if fs_ignore is None else fs_ignore)
+ self.fs_type_ignore = set(MyIO.nodev_fs() if fs_type_ignore is None else fs_type_ignore)
+ self.show_value = 0
+ self.show_disc_value = 0
+ self.show_overall = True
+ self.show_disc = 0
+ self.disc_map = None
+ Entry.__init__(self, *args, **kwargs)
+
+ @staticmethod
+ def nodev_fs():
+ ret = []
+ with open('/proc/filesystems', 'rb') as file:
+ data = file.read()
+ data = data.decode('utf-8', 'strict')[:-1].replace('\t', ' ').split('\n')
+ for line in data:
+ cols = line.split(' ')
+ if 'nodev' in cols[:-1]:
+ ret.append(cols[-1])
+ ret += ['fuse.gvfsd-fuse']
+ return ret
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ overall = self.show_overall
+ disc_map = self.disc_map
+ if overall and disc_map is not None:
+ x = 0
+ for text, disc in disc_map:
+ if col < x:
+ break
+ w = Bar.coloured_length(text)
+ if col < x + w:
+ if disc is not None:
+ self.show_disc = disc
+ break
+ x += w + 1
+ self.show_overall = not overall
+ elif button == MIDDLE_BUTTON and not self.show_overall:
+ self.show_disc_value = max(self.show_disc_value - 1, 0)
+ elif button == RIGHT_BUTTON and not self.show_overall:
+ self.show_disc_value = min(self.show_disc_value + 1, 4)
+ elif button == SCROLL_UP:
+ if self.show_overall:
+ self.show_value = min(self.show_value + 1, 13)
+ else:
+ show_disc = self.show_disc
+ if isinstance(show_disc, str):
+ try:
+ show_disc = [d.filesystem for d in self.get_discs()].index(show_disc)
+ except:
+ show_disc = -1
+ self.show_disc = show_disc + 1
+ elif button == SCROLL_DOWN:
+ if self.show_overall:
+ self.show_value = max(self.show_value - 1, 0)
+ else:
+ show_disc = self.show_disc
+ if isinstance(show_disc, str):
+ try:
+ show_disc = [d.filesystem for d in self.get_discs()].index(show_disc)
+ except:
+ show_disc = -1
+ self.show_disc = max(show_disc - 1, 0)
+ else:
+ return
+ self.invalidate()
+
+ def colour(self, percent):
+ colour = '39'
+ if percent < 25: colour = '32'
+ if percent > 50: colour = '33'
+ if percent > 90: colour = '31'
+ if percent > 95: colour = '39;41'
+ return colour
+
+ def unit(self, value):
+ units = ['', 'K', 'M', 'G', 'T', 'P', 'E']
+ unit = 0
+ while unit + 1 < len(units) and value >= 1024:
+ unit += 1
+ value /= 1024
+ return (value, units[unit])
+
+ def si(self, value, baseunit = 0):
+ unit = baseunit + 3
+ units = ['n', 'µ', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E']
+ while unit + 1 < len(units) and value >= 1000:
+ unit += 1
+ value /= 1000
+ return (value, units[unit])
+
+ def get_discs(self):
+ discs = Discs()
+ fs = [discs.filesystems[f] for f in sorted(discs.filesystems.keys()) if
+ f not in self.fs_ignore and
+ discs.filesystems[f].fstype not in self.fs_type_ignore and
+ f[0] == '/']
+ return fs
+
+ def function_overall(self):
+ df = []
+ if self.show_value == 0:
+ label = 'Df'
+ self.disc_map = [(label + ':', None)]
+ used = 0
+ available = 0
+ for disc in self.get_discs():
+ percent = disc.used * 100 / (disc.used + disc.available)
+ text = '\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)
+ df.append(text)
+ self.disc_map.append((text, disc.filesystem))
+ used += disc.used
+ available += disc.available
+ df.append(':')
+ percent = used * 100 / (used + available)
+ df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent))
+
+ elif self.show_value == 1:
+ label = 'Df'
+ self.disc_map = [(label + ':', None)]
+ used = 0
+ available = 0
+ for disc in self.get_discs():
+ percent = disc.used * 100 / (disc.used + disc.available)
+ text = '\033[%sm%.1f\033[0m%s' % (self.colour(percent), *self.unit(disc.available))
+ df.append(text)
+ self.disc_map.append((text, disc.filesystem))
+ used += disc.used
+ available += disc.available
+ df.append(':')
+ percent = used * 100 / (used + available)
+ df.append('\033[%sm%.1f\033[0m%s' % (self.colour(percent), *self.unit(available)))
+
+ elif self.show_value == 2:
+ label = 'Df(inodes)'
+ self.disc_map = [(label + ':', None)]
+ used = 0
+ available = 0
+ for disc in self.get_discs():
+ percent = disc.iused * 100 / (disc.iused + disc.ifree)
+ text = '\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)
+ df.append(text)
+ self.disc_map.append((text, disc.filesystem))
+ used += disc.iused
+ available += disc.ifree
+ df.append(':')
+ percent = used * 100 / (used + available)
+ df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent))
+
+ elif self.show_value == 3:
+ label = 'Dent'
+ dentry = DentryState()
+ percent = (dentry.nr_dentry - dentry.nr_unused) * 100 / dentry.nr_dentry
+ df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent))
+ df.append('%is' % dentry.age_limit)
+ df.append('%ipages' % dentry.want_pages)
+
+ elif self.show_value == 4:
+ label = 'Inode'
+ inode = InodeState()
+ percent = (inode.nr_inodes - inode.nr_free_inodes) * 100 / inode.nr_inodes
+ df.append('\033[%sm%.0f\033[0m%%%s' % (self.colour(percent), percent,
+ '' if inode.preshrink == 0 else ' preshrink'))
+ elif self.show_value == 5:
+ label = 'File'
+ files = Files()
+ percent = (files.nr_files - files.nr_free_files) * 100 / files.file_max
+ df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent))
+ df.append('%i/%i/%i' % (files.nr_files - files.nr_free_files, files.nr_files, files.file_max))
+
+ elif self.show_value == 6:
+ label = 'Lock'
+ locks = Locks().locks
+ ar, aw, mr, mw = 0, 0, 0, 0
+ for lock in locks:
+ if lock.mandatory:
+ if lock.shared:
+ mr += 1
+ else:
+ mw += 1
+ else:
+ if lock.shared:
+ ar += 1
+ else:
+ aw += 1
+ df.append('%iar' % ar)
+ df.append('%iaw' % aw)
+ df.append('%imr' % mr)
+ df.append('%imw' % mw)
+ df.append(':')
+ df.append('%ia' % (ar + aw))
+ df.append('%im' % (mr + mw))
+ df.append('%ir' % (ar + mr))
+ df.append('%iw' % (aw + mw))
+ df.append(':')
+ df.append('%i' % (ar + aw + mr + mw))
+
+ elif self.show_value == 7:
+ label = 'Rand'
+ random = Random()
+ df.append(str(random.poolsize))
+
+ elif self.show_value in (8, 11):
+ label = 'Disc(r %s)' % ('sum' if self.show_value == 8 else 'avg')
+ stats = DiscStats().devices.values()
+ r_complete, r_merge, r_sectors, r_time = 0, 0, 0, 0
+ for stat in stats:
+ r_complete += stat.r_complete
+ r_merge += stat.r_merge
+ r_sectors += stat.r_sectors
+ r_time += stat.r_time
+ n = 1 if self.show_value == 8 else len(stats)
+ r_complete /= n
+ r_merge /= n
+ r_sectors /= n
+ r_time /= n
+ df.append('%.1f%scompleted' % self.si(r_complete))
+ df.append('%.1f%smerge' % self.si(r_merge))
+ df.append('%.1f%ssectors' % self.si(r_sectors))
+ df.append('%.1f%ss' % self.si(r_time, -1))
+
+ elif self.show_value in (9, 12):
+ label = 'Disc(w %s)' % ('sum' if self.show_value == 9 else 'avg')
+ stats = DiscStats().devices.values()
+ w_complete, w_merge, w_sectors, w_time = 0, 0, 0, 0
+ for stat in stats:
+ w_complete += stat.w_complete
+ w_merge += stat.w_merge
+ w_sectors += stat.w_sectors
+ w_time += stat.w_time
+ n = 1 if self.show_value == 9 else len(stats)
+ w_complete /= n
+ w_merge /= n
+ w_sectors /= n
+ w_time /= n
+ df.append('%.1f%scomplete' % self.si(w_complete))
+ df.append('%.1f%smerge' % self.si(w_merge))
+ df.append('%.1f%ssectors' % self.si(w_sectors))
+ df.append('%.1f%ss' % self.si(w_time, -1))
+
+ elif self.show_value in (10, 13):
+ label = 'Disc(io %s)' % ('sum' if self.show_value == 10 else 'avg')
+ stats = DiscStats().devices.values()
+ io_current, io_time, io_weighted_time = 0, 0, 0
+ for stat in stats:
+ io_current += stat.io_current
+ io_time += stat.io_time
+ io_weighted_time += stat.io_weighted_time
+ n = 1 if self.show_value == 10 else len(stats)
+ io_current /= n
+ io_time /= n
+ io_weighted_time /= n
+ df.append('%.1f%s' % self.si(io_current))
+ df.append('%.1f%ss' % self.si(io_time, -1))
+ df.append('%.1f%ss(weighted)' % self.si(io_weighted_time, -1))
+
+ return '%s: %s' % (label, ' '.join(df))
+
+ def function_disc(self):
+ discs = self.get_discs()
+ disc = self.show_disc
+ if isinstance(disc, str):
+ for i, d in enumerate(discs):
+ if d.filesystem == disc:
+ disc = i
+ break
+ if isinstance(disc, str):
+ disc = 0
+ elif disc >= len(discs):
+ disc = len(discs) - 1
+ disc = discs[disc]
+ name = disc.filesystem
+ name = self.fs_name_map[name] if name in self.fs_name_map else name.split('/')[-1]
+ df = []
+
+ if self.show_disc_value > 1:
+ try:
+ devices = DiscStats().devices
+ device = None
+ fs = os.path.realpath(disc.filesystem)
+ stat = None
+ for dev in devices.keys():
+ if '/dev/' + dev == fs:
+ stat = devices[dev]
+ break
+ if stat is None:
+ self.show_disc_value = 0
+ except:
+ self.show_disc_value = 0
+
+ if self.show_disc_value == 0:
+ percent = disc.used * 100 / (disc.used + disc.available)
+ text = '\033[%sm%.0f\033[0m%%(%.1f%sB/%.f%sB)' % (self.colour(percent), percent,
+ *self.unit(disc.available),
+ *self.unit(disc.used + disc.available))
+ df.append(text)
+ percent = disc.iused * 100 / (disc.iused + disc.ifree)
+ text = '\033[%sm%.0f\033[0m%%(%.1f%s/%.1f%s)inodes' % (self.colour(percent), percent,
+ *self.si(disc.iused), *self.si(disc.inodes))
+ df.append(text)
+
+ elif self.show_disc_value == 1:
+ df.append(disc.fstype)
+ df.append(disc.mountpoint)
+
+ elif self.show_disc_value == 2:
+ name += '(r)'
+ df.append('%.1f%scompleted' % self.si(stat.r_complete))
+ df.append('%.1f%smerge' % self.si(stat.r_merge))
+ df.append('%.1f%ssectors' % self.si(stat.r_sectors))
+ df.append('%.1f%ss' % self.si(stat.r_time, -1))
+
+ elif self.show_disc_value == 3:
+ name += '(w)'
+ df.append('%.1f%scomplete' % self.si(stat.w_complete))
+ df.append('%.1f%smerge' % self.si(stat.w_merge))
+ df.append('%.1f%ssectors' % self.si(stat.w_sectors))
+ df.append('%.1f%ss' % self.si(stat.w_time, -1))
+
+ elif self.show_disc_value == 4:
+ name += '(io)'
+ df.append('%.1f%s' % self.si(stat.io_current))
+ df.append('%.1f%ss' % self.si(stat.io_time, -1))
+ df.append('%.1f%ss(weighted)' % self.si(stat.io_weighted_time, -1))
+
+ return '%s: %s' % (name, ' '.join(df))
+
+ def function(self):
+ try:
+ self.disc_map = None
+ if self.show_overall:
+ return self.function_overall()
+ else:
+ return self.function_disc()
+ except Exception as e:
+ return str(e)
+
+
+class MyTop(Entry):
+ def __init__(self, *args, **kwargs):
+ self.show_pid = False
+ self.show_cpu = True
+ self.show_label = True
+ self.show_nic = None
+ self.top_cmd = pdeath('HUP', 'top', '-b', '-n', '1', '-o', '%CPU', '-w', '10000')
+ self.refresh()
+ Entry.__init__(self, *args, **kwargs)
+ async(lambda : watch(5, t(self.refresh)), name = 'top')
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.show_pid = not self.show_pid
+ elif button == MIDDLE_BUTTON:
+ self.show_label = not self.show_label
+ elif button == RIGHT_BUTTON:
+ self.show_cpu = not self.show_cpu
+ else:
+ return
+ self.refresh()
+ self.invalidate()
+
+ def refresh(self):
+ top = spawn_read(*self.top_cmd).split('\n')
+ top = [line for line in top if not line.startswith('%')][6]
+ top = [col for col in top.replace('\t', ' ').split(' ') if not col == '']
+ text = 'Top: ' if self.show_label else ''
+ if self.show_pid:
+ text += top[0] + ' '
+ if self.show_cpu:
+ text += top[6] + ' '
+ text += ' '.join(top[10:])
+ self.text = text
+
+ def function(self):
+ return self.text
+
+
+class MyMOC(Entry):
+ def __init__(self, *args, ignore = None, **kwargs):
+ self.show_state = False
+ self.display = 0
+ self.function_display = Sometimes(self.function_display_, 4)
+ Entry.__init__(self, *args, **kwargs)
+
+ def invalidate(self):
+ self.function_display.counter = 0
+ Entry.invalidate(self)
+
+ def action(self, col, button, x, y):
+ if button == RIGHT_BUTTON:
+ self.show_state = not self.show_state
+ self.invalidate()
+ elif self.show_state:
+ if button == LEFT_BUTTON:
+ self.invalidate()
+ elif button == SCROLL_UP:
+ n = self.display + 1
+ if n >= 6:
+ return
+ self.display = n
+ self.invalidate()
+ elif button == SCROLL_DOWN:
+ n = self.display - 1
+ if n < 0:
+ return
+ self.display = n
+ self.invalidate()
+ else:
+ moc = MOC()
+ if moc.state == MOC.NOT_RUNNING:
+ return
+ elif button == LEFT_BUTTON:
+ if col < 5:
+ return
+ col -= 5
+ if col % 3 == 2:
+ return
+ col //= 3
+ if col == 0: async(lambda : moc.play().wait())
+ elif col == 1: async(lambda : moc.toggle_pause().wait())
+ elif col == 2: async(lambda : moc.stop().wait())
+ elif col == 3: async(lambda : moc.previous().wait())
+ elif col == 4: async(lambda : moc.next().wait())
+ elif button == SCROLL_UP: async(lambda : moc.seek(+5).wait())
+ elif button == SCROLL_DOWN: async(lambda : moc.seek(-5).wait())
+
+ def function_display_(self):
+ moc = MOC()
+ display = self.display
+ if display == 0 or moc.state in (MOC.NOT_RUNNING, MOC.STOPPED):
+ return 'Moc: %s' % { MOC.NOT_RUNNING : 'not running'
+ , MOC.STOPPED : 'stopped'
+ , MOC.PAUSED : 'paused'
+ , MOC.PLAYING : 'playing'}[moc.state]
+ key = ['SongTitle', 'Album', 'Artist', 'Title', 'File'][display - 1]
+ label = key.lower() if display != 1 else 'song'
+ return 'Moc(%s): %s' % (label, moc[key])
+
+ def function(self):
+ if not self.show_state:
+ return 'Moc: |> || [] |< >|'
+ return self.function_display()
+
+
+class MyIPAddress(Entry):
+ def __init__(self, *args, ignore = None, **kwargs):
+ self.ignore = ['lo'] if ignore is None else ignore
+ self.text = None
+ self.show_public = True
+ self.show_nic = None
+ Entry.__init__(self, *args, **kwargs)
+ def init():
+ self.refresh()
+ async(lambda : Clock(sync_to = 10 * Clock.MINUTES).continuous_sync(t(self.refresh)), name = 'ipaddress')
+ async(init, name = 'ipaddress')
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.show_public = not self.show_public
+ self.invalidate()
+ elif button == RIGHT_BUTTON:
+ async(self.refresh, name = 'ipaddress')
+ elif button in (SCROLL_UP, SCROLL_DOWN):
+ nic = self.show_nic
+ if nic is None:
+ return
+ nics = list(sorted(self.text[0].keys()))
+ try:
+ nic = nics.index(nic)
+ except:
+ if len(nics) == 0:
+ self.show_nic = None
+ self.invalidate()
+ else:
+ self.show_nic = nics[0]
+ self.invalidate()
+ nic += +1 if button == SCROLL_UP else -1
+ if 0 <= nic < len(nics):
+ self.show_nic = nics[nic]
+ self.invalidate()
+
+ def refresh(self):
+ text_private, text_public = {}, {}
+ ipa = IPAddress(*(self.ignore))
+ for nic in ipa.nics.keys():
+ (state, a4, a6, a) = ipa.nics[nic]
+ if state == IPAddress.DOWN:
+ label = '31'
+ elif state == IPAddress.UP:
+ label = '32'
+ elif state == IPAddress.UNKNOWN:
+ label = '33'
+ else:
+ label = '39'
+ label = '\033[%sm%s\033[0m' % (label, nic)
+ pub = label + ':'
+ prv = pub
+ if a4 is not None:
+ prv += ' ' + a4
+ if a6 is not None:
+ prv += ' ' + a6
+ elif a4 is None:
+ prv += ' no address'
+ pub += ' ' + a if a is not None else ' no address'
+ text_private[nic] = prv
+ text_public[nic] = pub
+ self.text = (text_private, text_public)
+ self.invalidate()
+
+ def function(self):
+ text = self.text
+ if text is None:
+ return '...'
+ text = text[1 if self.show_public else 0]
+ nic = self.show_nic
+ if nic is None or nic not in text:
+ if len(text.keys()) == 0:
+ self.show_nic = None
+ return 'No NIC available'
+ nic = sorted(text.keys())[0]
+ self.show_nic = nic
+ return text[nic]
+
+
+class MyLeapsec(Entry):
+ def __init__(self, *args, **kwargs):
+ self.announcement = None
+ Entry.__init__(self, *args, **kwargs)
+ def init():
+ self.refresh()
+ async(lambda : Clock(sync_to = Clock.MINUTES).continuous_sync(Sometimes(t(self.refresh), 12 * 60)), name = 'leapsec')
+ async(init, name = 'leapsec')
+
+ def action(self, col, button, x, y):
+ if button == RIGHT_BUTTON:
+ self.refresh()
+
+ def refresh(self):
+ leapanon = LeapSeconds()
+ found = -1
+ now = time.time()
+ for index in range(len(leapanon)):
+ if leapanon[index][3] >= now:
+ found = index
+ break
+ announcement = leapanon[found]
+ text = ('+%i' if announcement[4] > 0 else '%i') % announcement[4]
+ text += 's ' + ('\033[%sm%s\033[00m ago' if found < 0 else 'in \033[%sm%s\033[00m')
+ text += ' end of UTC %i-%02i-%0i' % announcement[:3]
+ if announcement[5] == LeapSeconds.SECONDARY:
+ text += ' (secondary)'
+ elif announcement[5] == LeapSeconds.OUT_OF_BAND:
+ text += ' (out of band)'
+ self.announcement = (text, announcement[3])
+ self.invalidate()
+
+ def dur(self, t):
+ s, t = t % 60, t // 60
+ m, t = t % 60, t // 60
+ h, d = t % 24, t // 24
+ if d > 0:
+ return '%id%ih%i\'%02i"' % (d, h, m, s)
+ elif h > 0:
+ return '%ih%i\'%02i"' % (h, m, s)
+ elif m > 0:
+ return '%i\'%02i"' % (m, s)
+ else:
+ return '%02is' % s
+
+ def colour(self, time_until):
+ c = '00'
+ if time_until >= 0:
+ if time_until < 10:
+ c = '41'
+ elif time_until < 60:
+ c = '31'
+ elif time_until < 60 * 60:
+ c = '33'
+ elif time_until < 24 * 60 * 60:
+ c = '32'
+ return c
+
+ def function(self):
+ if self.announcement is None:
+ return '...'
+ (text, when) = self.announcement
+ time_until = when - int(time.time())
+ return text % (self.colour(time_until), self.dur(abs(time_until)))
+
+
+class MyTimer(Entry):
+ def __init__(self, *args, **kwargs):
+ self.start = None
+ self.length = None
+ self.notified = False
+ self.pause_text = None
+ mqueue_map['timer'] = self.mqueue
+ Entry.__init__(self, *args, **kwargs)
+
+ def mqueue(self, args):
+ if args[1] == 'stop':
+ self.stop()
+ elif args[1] in ('pause', 'resume'):
+ self.pause()
+ else:
+ duration = args[1].split(':')
+ duration.reverse()
+ seconds = 0
+ if len(duration) > 0: seconds += int(duration[0])
+ if len(duration) > 1: seconds += int(duration[1]) * 60
+ if len(duration) > 2: seconds += int(duration[2]) * 60 * 60
+ if len(duration) > 3: seconds += int(duration[3]) * 60 * 60 * 24
+ self.start = time.time()
+ self.length = seconds
+ self.notified = False
+ self.pause_text = None
+ self.invalidate()
+
+ def action(self, col, button, x, y):
+ if button == LEFT_BUTTON:
+ self.pause()
+ elif button == RIGHT_BUTTON:
+ self.stop()
+
+ def pause(self):
+ if self.pause_text is not None:
+ self.start = time.time()
+ self.pause_text = None
+ elif self.length - int(time.time() - self.start) < 0:
+ self.start, self.length, self.notified, self.pause_text = None, None, False, None
+ else:
+ self.pause_text = ''
+ self.length -= int(time.time() - self.start)
+ self.pause_text = self.dur(self.length)
+ self.invalidate()
+
+ def stop(self):
+ self.start = None
+ self.length = None
+ self.notified = False
+ self.pause_text = None
+ self.invalidate()
+
+ def dur(self, t):
+ s, t = t % 60, t // 60
+ m, t = t % 60, t // 60
+ h, d = t % 24, t // 24
+ if d > 0:
+ return '%id %i:%02i:%02i' % (d, h, m, s)
+ elif h > 0:
+ return '%i:%02i:%02i' % (h, m, s)
+ else:
+ return '%i:%02i' % (m, s)
+
+ def notify(self):
+ subprocess.Popen(['notify-send', '-u', 'critical', 'You are done with your task']).wait()
+
+ def wall(self):
+ subprocess.Popen(['wall', 'You are done with your task']).wait()
+
+ def function(self):
+ if self.pause_text is not None:
+ return '%s (paused)' % self.pause_text
+ if self.start is None:
+ return 'Timer inactive'
+ countdown = self.length - int(time.time() - self.start)
+ if countdown > 0:
+ return self.dur(countdown)
+ if not self.notified:
+ self.notified = True
+ async(self.notify, name = 'timer notify')
+ async(self.wall, name = 'timer wall')
+ countdown %= 2
+ if countdown == 0:
+ return '\033[37;41mYou are done\033[00m'
+ else:
+ return '\033[31mYou are done\033[00m'
+
+
+
+def mqueue_wait():
+ import posix_ipc
+ qkey = '/.xpybar.' + os.environ['DISPLAY'].split('.')[0]
+ q = posix_ipc.MessageQueue(qkey, posix_ipc.O_CREAT, 0o600, 8, 128)
+ while True:
+ try:
+ message = q.receive(None)[0].decode('utf-8', 'replace').split(' ')
+ if message[0] in mqueue_map:
+ try:
+ mqueue_map[message[0]](message)
+ except Exception as err:
+ print('%s: %s' % (sys.argv[0], str(err)), file = sys.stderr, flush = True)
+ else:
+ print('%s: unrecognised message: %s' % (sys.argv[0], ' '.join(message)), file = sys.stderr, flush = True)
+ except:
+ time.sleep(1)
+
+
+
+mqueue_map = {}
+
+myxmonad = MyXMonad(None)
+myscroll = MyScroll(None)
+
+functions = [ [ myscroll
+ , myxmonad
+ , None
+ , MyTimer (None)
+ , MyNetwork (lambda f : Clocked(f, 2))
+ , MyMemory (lambda f : Clocked(f, 2))
+ , MyCPU (lambda f : Clocked(f, 2))
+ , MyBattery (lambda f : Clocked(f, 10))
+ , MyALSA (None)
+ , MyClock (lambda f : Clocked(f, 1))
+ ]
+ , [ myscroll
+ , myxmonad
+ , None
+ , MyTop (None)
+ , MyIO (lambda f : Clocked(f, 10))
+ , MyStat (lambda f : Clocked(f, 10))
+ , MyNews (None)
+ , MyWeather (None)
+ , MyComputer (lambda f : Clocked(f, 20))
+ ]
+ , [ myscroll
+ , myxmonad
+ , None
+ , MyIPAddress(lambda f : Clocked(f, 20))
+ , MyLeapsec (None)
+ , MyMOC (None)
+ ]
+ ]
+
+HEIGHT = 0
+groups = [Group(f) for f in functions]
+groupi = 0
+group = groups[groupi]
+semaphore = threading.Semaphore()
+
+def update_per_clock():
+ if semaphore.acquire(blocking = False):
+ try:
+ for g in groups:
+ for f in g.functions:
+ if isinstance(f.wrapped, Clocked):
+ f(True)
+ finally:
+ semaphore.release()
+ invalidate()
+
+start_ = start
+def start():
+ start_()
+ bar.clear()
+ get_display().flush()
+ async(lambda : clock.continuous_sync(t(update_per_clock)), name = 'clock')
+ async(mqueue_wait, name = 'mqueue')
+
+def redraw():
+ if semaphore.acquire(blocking = False):
+ try:
+ gr = groups[groupi]
+ for g in groups:
+ if g is not gr:
+ for f in g.functions:
+ f()
+ values = gr.pattern % tuple(f() for f in gr.functions)
+ bar.partial_clear(0, bar.width, 10, 0, 2, values)
+ bar.draw_coloured_splitted_text(0, bar.width, 10, 0, 2, values)
+ finally:
+ semaphore.release()
+ return True
+ return False
+
+def unhandled_event(e):
+ global groups, groupi, group
+ if isinstance(e, Xlib.protocol.event.ButtonPress):
+ y = e.event_y
+ x = e.event_x
+ row = y // HEIGHT_PER_LINE
+ lcol = x // bar.font_width
+ rcol = (bar.width - x) // bar.font_width
+ button = e.detail
+ if button in (FORWARD_BUTTON, BACKWARD_BUTTON):
+ groupi = (groupi + (+1 if button == BACKWARD_BUTTON else -1)) % len(groups)
+ group = groups[groupi]
+ invalidate()
+ else:
+ for f in group.posupdate:
+ f.update_position()
+ for f in group.functions:
+ if f.click(row, lcol, rcol, button, x, y):
+ break
+