qutebrowser: Own file

hm/desktop/frobar/.dev/barng.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+import typing
+import subprocess
+import time
+
+# CORE
+
+
+class Notifier:
+    pass
+
+
+class Section:
+    def __init__(self) -> None:
+        self.text = b"(Loading)"
+
+
+class Module:
+    def __init__(self) -> None:
+        self.bar: "Bar"
+        self.section = Section()
+        self.sections = [self.section]
+
+
+class Alignment:
+    def __init__(self, *modules: Module) -> None:
+        self.bar: "Bar"
+        self.modules = modules
+        for module in modules:
+            module.bar = self.bar
+
+
+class Screen:
+    def __init__(self, left: Alignment = Alignment(), right: Alignment = Alignment()) -> None:
+        self.bar: "Bar"
+        self.left = left
+        self.left.bar = self.bar
+        self.right = right or Alignment()
+        self.right.bar = self.bar
+
+
+class Bar:
+    def __init__(self, *screens: Screen) -> None:
+        self.screens = screens
+        for screen in screens:
+            screen.bar = self
+        self.process = subprocess.Popen(["lemonbar"], stdin=subprocess.PIPE)
+
+    def display(self) -> None:
+        string = b""
+        for s, screen in enumerate(self.screens):
+            string += b"%%{S%d}" % s
+            for control, alignment in [(b'%{l}', screen.left), (b'%{r}', screen.right)]:
+                string += control
+                for module in alignment.modules:
+                    for section in module.sections:
+                        string += b"<%b> |" % section.text
+
+        string += b"\n"
+        print(string)
+        assert self.process.stdin
+        self.process.stdin.write(string)
+        self.process.stdin.flush()
+
+    def run(self) -> None:
+        while True:
+            self.display()
+            time.sleep(1)
+
+
+# REUSABLE
+
+class ClockNotifier(Notifier):
+    def run(self) -> None:
+        while True:
+    def __init__(self, text: bytes):
+        super().__init__()
+        self.section.text = text
+
+class StaticModule(Module):
+    def __init__(self, text: bytes):
+        super().__init__()
+        self.section.text = text
+
+
+# USER
+
+if __name__ == "__main__":
+    bar = Bar(
+        Screen(Alignment(StaticModule(b"A"))),
+        Screen(Alignment(StaticModule(b"B"))),
+    )
+    bar.run()

hm/desktop/frobar/.dev/oldbar.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+
+"""
+Debugging script
+"""
+
+import i3ipc
+import os
+import psutil
+
+# import alsaaudio
+from time import time
+import subprocess
+
+i3 = i3ipc.Connection()
+lemonbar = subprocess.Popen(["lemonbar", "-b"], stdin=subprocess.PIPE)
+
+# Utils
+def upChart(p):
+    block = " ▁▂▃▄▅▆▇█"
+    return block[round(p * (len(block) - 1))]
+
+
+def humanSizeOf(num, suffix="B"):  # TODO Credit
+    for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
+        if abs(num) < 1024.0:
+            return "%3.0f%2s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.0f%2s%s" % (num, "Yi", suffix)
+
+
+# Values
+mode = ""
+container = i3.get_tree().find_focused()
+workspaces = i3.get_workspaces()
+outputs = i3.get_outputs()
+
+username = os.environ["USER"]
+hostname = os.environ["HOSTNAME"]
+if "-" in hostname:
+    hostname = hostname.split("-")[-1]
+
+oldNetIO = dict()
+oldTime = time()
+
+
+def update():
+    activeOutputs = sorted(
+        sorted(list(filter(lambda o: o.active, outputs)), key=lambda o: o.rect.y),
+        key=lambda o: o.rect.x,
+    )
+    z = ""
+    for aOutput in range(len(activeOutputs)):
+        output = activeOutputs[aOutput]
+        # Mode || Workspaces
+        t = []
+        if mode != "":
+            t.append(mode)
+        else:
+            t.append(
+                " ".join(
+                    [
+                        (w.name.upper() if w.focused else w.name)
+                        for w in workspaces
+                        if w.output == output.name
+                    ]
+                )
+            )
+
+        # Windows Title
+        # if container:
+        #    t.append(container.name)
+
+        # CPU
+        t.append(
+            "C" + "".join([upChart(p / 100) for p in psutil.cpu_percent(percpu=True)])
+        )
+
+        # Memory
+        t.append(
+            "M"
+            + str(round(psutil.virtual_memory().percent))
+            + "% "
+            + "S"
+            + str(round(psutil.swap_memory().percent))
+            + "%"
+        )
+
+        # Disks
+        d = []
+        for disk in psutil.disk_partitions():
+            e = ""
+            if disk.device.startswith("/dev/sd"):
+                e += "S" + disk.device[-2:].upper()
+            elif disk.device.startswith("/dev/mmcblk"):
+                e += "M" + disk.device[-3] + disk.device[-1]
+            else:
+                e += "?"
+            e += " "
+            e += str(round(psutil.disk_usage(disk.mountpoint).percent)) + "%"
+            d.append(e)
+        t.append(" ".join(d))
+
+        # Network
+        netStats = psutil.net_if_stats()
+        netIO = psutil.net_io_counters(pernic=True)
+        net = []
+        for iface in filter(lambda i: i != "lo" and netStats[i].isup, netStats.keys()):
+            s = ""
+            if iface.startswith("eth"):
+                s += "E"
+            elif iface.startswith("wlan"):
+                s += "W"
+            else:
+                s += "?"
+
+            s += " "
+            now = time()
+            global oldNetIO, oldTime
+
+            sent = (
+                (oldNetIO[iface].bytes_sent if iface in oldNetIO else 0)
+                - (netIO[iface].bytes_sent if iface in netIO else 0)
+            ) / (oldTime - now)
+            recv = (
+                (oldNetIO[iface].bytes_recv if iface in oldNetIO else 0)
+                - (netIO[iface].bytes_recv if iface in netIO else 0)
+            ) / (oldTime - now)
+            s += (
+                "↓"
+                + humanSizeOf(abs(recv), "B/s")
+                + " ↑"
+                + humanSizeOf(abs(sent), "B/s")
+            )
+
+            oldNetIO = netIO
+            oldTime = now
+
+            net.append(s)
+        t.append(" ".join(net))
+
+        # Battery
+        if os.path.isdir("/sys/class/power_supply/BAT0"):
+            with open("/sys/class/power_supply/BAT0/charge_now") as f:
+                charge_now = int(f.read())
+            with open("/sys/class/power_supply/BAT0/charge_full_design") as f:
+                charge_full = int(f.read())
+            t.append("B" + str(round(100 * charge_now / charge_full)) + "%")
+
+        # Volume
+        # t.append('V ' + str(alsaaudio.Mixer('Master').getvolume()[0]) + '%')
+
+        t.append(username + "@" + hostname)
+
+        # print(' - '.join(t))
+        # t = [output.name]
+
+        z += " - ".join(t) + "%{S" + str(aOutput + 1) + "}"
+        # lemonbar.stdin.write(bytes(' - '.join(t), 'utf-8'))
+        # lemonbar.stdin.write(bytes('%{S' + str(aOutput + 1) + '}', 'utf-8'))
+
+    lemonbar.stdin.write(bytes(z + "\n", "utf-8"))
+    lemonbar.stdin.flush()
+
+
+# Event listeners
+def on_mode(i3, e):
+    global mode
+    if e.change == "default":
+        mode = ""
+    else:
+        mode = e.change
+    update()
+
+
+i3.on("mode", on_mode)
+
+# def on_window_focus(i3, e):
+#    global container
+#    container = e.container
+#    update()
+#
+# i3.on("window::focus", on_window_focus)
+
+
+def on_workspace_focus(i3, e):
+    global workspaces
+    workspaces = i3.get_workspaces()
+    update()
+
+
+i3.on("workspace::focus", on_workspace_focus)
+
+# Starting
+
+update()
+
+
+i3.main()

hm/desktop/frobar/.dev/pip.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+
+"""
+Beautiful script
+"""
+
+import subprocess
+import time
+import datetime
+import os
+import multiprocessing
+import i3ipc
+import difflib
+
+# Constants
+FONT = "DejaVuSansMono Nerd Font Mono"
+
+# TODO Update to be in sync with base16
+thm = [
+    "#002b36",
+    "#dc322f",
+    "#859900",
+    "#b58900",
+    "#268bd2",
+    "#6c71c4",
+    "#2aa198",
+    "#93a1a1",
+    "#657b83",
+    "#dc322f",
+    "#859900",
+    "#b58900",
+    "#268bd2",
+    "#6c71c4",
+    "#2aa198",
+    "#fdf6e3",
+]
+fg = "#93a1a1"
+bg = "#002b36"
+
+THEMES = {
+    "CENTER": (fg, bg),
+    "DEFAULT": (thm[0], thm[8]),
+    "1": (thm[0], thm[9]),
+    "2": (thm[0], thm[10]),
+    "3": (thm[0], thm[11]),
+    "4": (thm[0], thm[12]),
+    "5": (thm[0], thm[13]),
+    "6": (thm[0], thm[14]),
+    "7": (thm[0], thm[15]),
+}
+
+# Utils
+
+
+def fitText(text, size):
+    """
+    Add spaces or cut a string to be `size` characters long
+    """
+    if size > 0:
+        t = len(text)
+        if t >= size:
+            return text[:size]
+        else:
+            diff = size - t
+            return text + " " * diff
+    else:
+        return ""
+
+
+def fgColor(theme):
+    global THEMES
+    return THEMES[theme][0]
+
+
+def bgColor(theme):
+    global THEMES
+    return THEMES[theme][1]
+
+
+class Section:
+    def __init__(self, theme="DEFAULT"):
+        self.text = ""
+        self.size = 0
+        self.toSize = 0
+        self.theme = theme
+        self.visible = False
+        self.name = ""
+
+    def update(self, text):
+        if text == "":
+            self.toSize = 0
+        else:
+            if len(text) < len(self.text):
+                self.text = text + self.text[len(text) :]
+            else:
+                self.text = text
+            self.toSize = len(text) + 3
+
+    def updateSize(self):
+        """
+        Set the size for the next frame of animation
+        Return if another frame is needed
+        """
+        if self.toSize > self.size:
+            self.size += 1
+        elif self.toSize < self.size:
+            self.size -= 1
+        self.visible = self.size
+        return self.toSize == self.size
+
+    def draw(self, left=True, nextTheme="DEFAULT"):
+        s = ""
+        if self.visible:
+            if not left:
+                if self.theme == nextTheme:
+                    s += ""
+                else:
+                    s += "%{F" + bgColor(self.theme) + "}"
+                    s += "%{B" + bgColor(nextTheme) + "}"
+                    s += ""
+            s += "%{F" + fgColor(self.theme) + "}"
+            s += "%{B" + bgColor(self.theme) + "}"
+            s += " " if self.size > 1 else ""
+            s += fitText(self.text, self.size - 3)
+            s += " " if self.size > 2 else ""
+            if left:
+                if self.theme == nextTheme:
+                    s += ""
+                else:
+                    s += "%{F" + bgColor(self.theme) + "}"
+                    s += "%{B" + bgColor(nextTheme) + "}"
+                    s += ""
+        return s
+
+
+# Section definition
+sTime = Section("3")
+
+hostname = os.environ["HOSTNAME"].split(".")[0]
+sHost = Section("2")
+sHost.update(
+    os.environ["USER"] + "@" + hostname.split("-")[-1] if "-" in hostname else hostname
+)
+
+
+# Groups definition
+gLeft = []
+gRight = [sTime, sHost]
+
+# Bar handling
+bar = subprocess.Popen(["lemonbar", "-f", FONT, "-b"], stdin=subprocess.PIPE)
+
+
+def updateBar():
+    global timeLastUpdate, timeUpdate
+    global gLeft, gRight
+    global outputs
+
+    text = ""
+    for oi in range(len(outputs)):
+        output = outputs[oi]
+        gLeftFiltered = list(
+            filter(
+                lambda s: s.visible and (not s.output or s.output == output.name), gLeft
+            )
+        )
+        tLeft = ""
+        l = len(gLeftFiltered)
+        for gi in range(l):
+            g = gLeftFiltered[gi]
+            # Next visible section for transition
+            nextTheme = gLeftFiltered[gi + 1].theme if gi + 1 < l else "CENTER"
+            tLeft = tLeft + g.draw(True, nextTheme)
+
+        tRight = ""
+        for gi in range(len(gRight)):
+            g = gRight[gi]
+            nextTheme = "CENTER"
+            for gn in gRight[gi + 1 :]:
+                if gn.visible:
+                    nextTheme = gn.theme
+                    break
+            tRight = g.draw(False, nextTheme) + tRight
+        text += (
+            "%{l}"
+            + tLeft
+            + "%{r}"
+            + tRight
+            + "%{B"
+            + bgColor("CENTER")
+            + "}"
+            + "%{S"
+            + str(oi + 1)
+            + "}"
+        )
+
+    bar.stdin.write(bytes(text + "\n", "utf-8"))
+    bar.stdin.flush()
+
+
+# Values
+i3 = i3ipc.Connection()
+outputs = []
+
+
+def on_output():
+    global outputs
+    outputs = sorted(
+        sorted(
+            list(filter(lambda o: o.active, i3.get_outputs())), key=lambda o: o.rect.y
+        ),
+        key=lambda o: o.rect.x,
+    )
+
+
+on_output()
+
+
+def on_workspace_focus():
+    global i3
+    global gLeft
+    workspaces = i3.get_workspaces()
+    wNames = [w.name for w in workspaces]
+    sNames = [s.name for s in gLeft]
+
+    newGLeft = []
+
+    def actuate(section, workspace):
+        if workspace:
+            section.name = workspace.name
+            section.output = workspace.output
+            if workspace.visible:
+                section.update(workspace.name)
+            else:
+                section.update(workspace.name.split(" ")[0])
+
+            if workspace.focused:
+                section.theme = "4"
+            elif workspace.urgent:
+                section.theme = "1"
+            else:
+                section.theme = "6"
+        else:
+            section.update("")
+            section.theme = "6"
+
+    for tag, i, j, k, l in difflib.SequenceMatcher(None, sNames, wNames).get_opcodes():
+        if tag == "equal":  # If the workspaces didn't changed
+            for a in range(j - i):
+                workspace = workspaces[k + a]
+                section = gLeft[i + a]
+                actuate(section, workspace)
+                newGLeft.append(section)
+        if tag in ("delete", "replace"):  # If the workspaces were removed
+            for section in gLeft[i:j]:
+                if section.visible:
+                    actuate(section, None)
+                    newGLeft.append(section)
+                else:
+                    del section
+        if tag in ("insert", "replace"):  # If the workspaces were removed
+            for workspace in workspaces[k:l]:
+                section = Section()
+                actuate(section, workspace)
+                newGLeft.append(section)
+    gLeft = newGLeft
+
+    updateBar()
+
+
+on_workspace_focus()
+
+
+def i3events(i3childPipe):
+    global i3
+
+    # Proxy functions
+    def on_workspace_focus(i3, e):
+        global i3childPipe
+        i3childPipe.send("on_workspace_focus")
+
+    i3.on("workspace::focus", on_workspace_focus)
+
+    def on_output(i3, e):
+        global i3childPipe
+        i3childPipe.send("on_output")
+
+    i3.on("output", on_output)
+
+    i3.main()
+
+
+i3parentPipe, i3childPipe = multiprocessing.Pipe()
+i3process = multiprocessing.Process(target=i3events, args=(i3childPipe,))
+i3process.start()
+
+
+def updateValues():
+    # Time
+    now = datetime.datetime.now()
+    sTime.update(now.strftime("%x %X"))
+
+
+def updateAnimation():
+    for s in set(gLeft + gRight):
+        s.updateSize()
+    updateBar()
+
+
+lastUpdate = 0
+while True:
+    now = time.time()
+    if i3parentPipe.poll():
+        msg = i3parentPipe.recv()
+        if msg == "on_workspace_focus":
+            on_workspace_focus()
+        elif msg == "on_output":
+            on_output()
+            # TODO Restart lemonbar
+        else:
+            print(msg)
+    updateAnimation()
+    if now >= lastUpdate + 1:
+        updateValues()
+        lastUpdate = now
+
+    time.sleep(0.05)

hm/desktop/frobar/.dev/x.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+import Xlib.display
+
+dis = Xlib.display.Display()
+
+nb = dis.screen_count()
+
+for s in range(nb):
+    print(s)

hm/desktop/frobar/.gitignore

@@ -0,0 +1,3 @@
+dist/*
+frobar.egg-info/*
+__pycache__

hm/desktop/frobar/default.nix

@@ -0,0 +1,48 @@
+{ pkgs ? import <nixpkgs> { config = { }; overlays = [ ]; }, ... }:
+# Tried using pyproject.nix but mpd2 dependency wouldn't resolve,
+# is called pyton-mpd2 on PyPi but mpd2 in nixpkgs.
+let
+  frobar = pkgs.python3Packages.buildPythonApplication {
+    pname = "frobar";
+    version = "2.0";
+
+    runtimeInputs = with pkgs; [ lemonbar-xft wirelesstools ];
+    propagatedBuildInputs = with pkgs.python3Packages; [
+      coloredlogs
+      notmuch
+      i3ipc
+      mpd2
+      psutil
+      pulsectl
+      pyinotify
+    ];
+    makeWrapperArgs = [ "--prefix PATH : ${pkgs.lib.makeBinPath (with pkgs; [ lemonbar-xft wirelesstools ])}" ];
+
+    src = ./.;
+  };
+in
+{
+  config = {
+    xsession.windowManager.i3.config.bars = [ ];
+    programs.autorandr.hooks.postswitch = {
+      frobar = "${pkgs.systemd}/bin/systemctl --user restart frobar";
+    };
+    systemd.user.services.frobar = {
+      Unit = {
+        Description = "frobar";
+        After = [ "graphical-session-pre.target" ];
+        PartOf = [ "graphical-session.target" ];
+      };
+
+      Service = {
+        # Wait for i3 to start. Can't use ExecStartPre because otherwise it blocks graphical-session.target, and there's nothing i3/systemd
+        # TODO Do that better
+        ExecStart = ''${pkgs.bash}/bin/bash -c "while ! ${pkgs.i3}/bin/i3-msg; do ${pkgs.coreutils}/bin/sleep 1; done; ${frobar}/bin/frobar"''; 
+      };
+
+      Install = { WantedBy = [ "graphical-session.target" ]; };
+    };
+  };
+}
+# TODO Connection with i3 is lost on start sometimes, more often than with Arch?
+# TODO Restore ability to build frobar with nix-build

hm/desktop/frobar/frobar/__init__.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+from frobar.providers import *
+
+# TODO If multiple screen, expand the sections and share them
+# TODO Graceful exit
+
+def run():
+    Bar.init()
+    Updater.init()
+
+    WORKSPACE_THEME = 0
+    FOCUS_THEME = 3
+    URGENT_THEME = 1
+    CUSTOM_SUFFIXES = "▲■"
+
+    customNames = dict()
+    for i in range(len(CUSTOM_SUFFIXES)):
+        short = str(i + 1)
+        full = short + " " + CUSTOM_SUFFIXES[i]
+        customNames[short] = full
+    Bar.addSectionAll(
+        I3WorkspacesProvider(
+            theme=WORKSPACE_THEME,
+            themeFocus=FOCUS_THEME,
+            themeUrgent=URGENT_THEME,
+            themeMode=URGENT_THEME,
+            customNames=customNames,
+        ),
+        BarGroupType.LEFT,
+    )
+
+    # TODO Middle
+    Bar.addSectionAll(MpdProvider(theme=7), BarGroupType.LEFT)
+    # Bar.addSectionAll(I3WindowTitleProvider(), BarGroupType.LEFT)
+
+    # TODO Computer modes
+
+    SYSTEM_THEME = 2
+    DANGER_THEME = FOCUS_THEME
+    CRITICAL_THEME = URGENT_THEME
+    Bar.addSectionAll(CpuProvider(), BarGroupType.RIGHT)
+    Bar.addSectionAll(RamProvider(), BarGroupType.RIGHT)
+    Bar.addSectionAll(TemperatureProvider(), BarGroupType.RIGHT)
+    Bar.addSectionAll(BatteryProvider(), BarGroupType.RIGHT)
+
+    # Peripherals
+    PERIPHERAL_THEME = 5
+    NETWORK_THEME = 4
+    # TODO Disk space provider
+    # TODO Screen (connected, autorandr configuration, bbswitch) provider
+    Bar.addSectionAll(PulseaudioProvider(theme=PERIPHERAL_THEME), BarGroupType.RIGHT)
+    Bar.addSectionAll(RfkillProvider(theme=PERIPHERAL_THEME), BarGroupType.RIGHT)
+    Bar.addSectionAll(NetworkProvider(theme=NETWORK_THEME), BarGroupType.RIGHT)
+
+    # Personal
+    PERSONAL_THEME = 0
+    # Bar.addSectionAll(KeystoreProvider(theme=PERSONAL_THEME), BarGroupType.RIGHT)
+    # Bar.addSectionAll(NotmuchUnreadProvider(dir='~/.mail/', theme=PERSONAL_THEME), BarGroupType.RIGHT)
+    # Bar.addSectionAll(TodoProvider(dir='~/.vdirsyncer/currentCalendars/', theme=PERSONAL_THEME), BarGroupType.RIGHT)
+
+    TIME_THEME = 6
+    Bar.addSectionAll(TimeProvider(theme=TIME_THEME), BarGroupType.RIGHT)
+
+    # Bar.run()

hm/desktop/frobar/frobar/display.py

@@ -0,0 +1,723 @@
+#!/usr/bin/env python3
+
+import enum
+import logging
+import os
+import signal
+import subprocess
+import threading
+import time
+
+import coloredlogs
+import i3ipc
+
+from frobar.notbusy import notBusy
+
+coloredlogs.install(level="DEBUG", fmt="%(levelname)s %(message)s")
+log = logging.getLogger()
+
+
+# TODO Allow deletion of Bar, BarGroup and Section for screen changes
+# IDEA Use i3 ipc events rather than relying on xrandr or Xlib (less portable
+# but easier)
+# TODO Optimize to use write() calls instead of string concatenation (writing
+# BarGroup strings should be a good compromise)
+# TODO Use bytes rather than strings
+# TODO Use default colors of lemonbar sometimes
+# TODO Adapt bar height with font height
+# TODO OPTI Static text objects that update its parents if modified
+# TODO forceSize and changeText are different
+
+
+class BarGroupType(enum.Enum):
+    LEFT = 0
+    RIGHT = 1
+    # TODO Middle
+    # MID_LEFT = 2
+    # MID_RIGHT = 3
+
+
+class BarStdoutThread(threading.Thread):
+    def run(self) -> None:
+        while Bar.running:
+            handle = Bar.process.stdout.readline().strip()
+            if not len(handle):
+                Bar.stop()
+            if handle not in Bar.actionsH2F:
+                log.error("Unknown action: {}".format(handle))
+                continue
+            function = Bar.actionsH2F[handle]
+            function()
+
+
+class Bar:
+    """
+    One bar for each screen
+    """
+
+    # Constants
+    FONTS = ["DejaVuSansM Nerd Font"]
+    FONTSIZE = 10
+
+    @staticmethod
+    def init() -> None:
+        Bar.running = True
+        Section.init()
+
+        cmd = ["lemonbar", "-b", "-a", "64"]
+        for font in Bar.FONTS:
+            cmd += ["-f", "{}:size={}".format(font, Bar.FONTSIZE)]
+        Bar.process = subprocess.Popen(
+            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE
+        )
+        Bar.stdoutThread = BarStdoutThread()
+        Bar.stdoutThread.start()
+
+        # Debug
+        Bar(0)
+        # Bar(1)
+
+    @staticmethod
+    def stop() -> None:
+        Bar.running = False
+        Bar.process.kill()
+
+        # TODO This is not really the best way to do it I guess
+        os.killpg(os.getpid(), signal.SIGTERM)
+
+    @staticmethod
+    def run() -> None:
+        Bar.forever()
+        i3 = i3ipc.Connection()
+
+        def doStop(*args) -> None:
+            Bar.stop()
+            print(88)
+
+        try:
+            i3.on("ipc_shutdown", doStop)
+            i3.main()
+        except BaseException:
+            print(93)
+            Bar.stop()
+
+    # Class globals
+    everyone = set()
+    string = ""
+    process = None
+    running = False
+
+    nextHandle = 0
+    actionsF2H = dict()
+    actionsH2F = dict()
+
+    @staticmethod
+    def getFunctionHandle(function):
+        assert callable(function)
+        if function in Bar.actionsF2H.keys():
+            return Bar.actionsF2H[function]
+
+        handle = "{:x}".format(Bar.nextHandle).encode()
+        Bar.nextHandle += 1
+
+        Bar.actionsF2H[function] = handle
+        Bar.actionsH2F[handle] = function
+
+        return handle
+
+    @staticmethod
+    def forever():
+        Bar.process.wait()
+        Bar.stop()
+
+    def __init__(self, screen):
+        assert isinstance(screen, int)
+        self.screen = "%{S" + str(screen) + "}"
+        self.groups = dict()
+
+        for groupType in BarGroupType:
+            group = BarGroup(groupType, self)
+            self.groups[groupType] = group
+
+        self.childsChanged = False
+
+        self.everyone.add(self)
+
+    @staticmethod
+    def addSectionAll(section, group, screens=None):
+        """
+        .. note::
+            Add the section before updating it for the first time.
+        """
+        assert isinstance(section, Section)
+        assert isinstance(group, BarGroupType)
+        # TODO screens selection
+        for bar in Bar.everyone:
+            bar.addSection(section, group=group)
+
+    def addSection(self, section, group):
+        assert isinstance(section, Section)
+        assert isinstance(group, BarGroupType)
+        self.groups[group].addSection(section)
+
+    def update(self):
+        if self.childsChanged:
+            self.string = self.screen
+            self.string += self.groups[BarGroupType.LEFT].string
+            self.string += self.groups[BarGroupType.RIGHT].string
+
+            self.childsChanged = False
+
+    @staticmethod
+    def updateAll():
+        if Bar.running:
+            Bar.string = ""
+            for bar in Bar.everyone:
+                bar.update()
+                Bar.string += bar.string
+            # Color for empty sections
+            Bar.string += BarGroup.color(*Section.EMPTY)
+
+            # print(Bar.string)
+            Bar.process.stdin.write(bytes(Bar.string + "\n", "utf-8"))
+            Bar.process.stdin.flush()
+
+
+class BarGroup:
+    """
+    One for each group of each bar
+    """
+
+    everyone = set()
+
+    def __init__(self, groupType, parent):
+        assert isinstance(groupType, BarGroupType)
+        assert isinstance(parent, Bar)
+
+        self.groupType = groupType
+        self.parent = parent
+
+        self.sections = list()
+        self.string = ""
+        self.parts = []
+
+        #: One of the sections that had their theme or visibility changed
+        self.childsThemeChanged = False
+
+        #: One of the sections that had their text (maybe their size) changed
+        self.childsTextChanged = False
+
+        BarGroup.everyone.add(self)
+
+    def addSection(self, section):
+        self.sections.append(section)
+        section.addParent(self)
+
+    def addSectionAfter(self, sectionRef, section):
+        index = self.sections.index(sectionRef)
+        self.sections.insert(index + 1, section)
+        section.addParent(self)
+
+    ALIGNS = {BarGroupType.LEFT: "%{l}", BarGroupType.RIGHT: "%{r}"}
+
+    @staticmethod
+    def fgColor(color):
+        return "%{F" + (color or "-") + "}"
+
+    @staticmethod
+    def bgColor(color):
+        return "%{B" + (color or "-") + "}"
+
+    @staticmethod
+    def color(fg, bg):
+        return BarGroup.fgColor(fg) + BarGroup.bgColor(bg)
+
+    def update(self):
+        if self.childsThemeChanged:
+            parts = [BarGroup.ALIGNS[self.groupType]]
+
+            secs = [sec for sec in self.sections if sec.visible]
+            lenS = len(secs)
+            for s in range(lenS):
+                sec = secs[s]
+                theme = Section.THEMES[sec.theme]
+                if self.groupType == BarGroupType.LEFT:
+                    oSec = secs[s + 1] if s < lenS - 1 else None
+                else:
+                    oSec = secs[s - 1] if s > 0 else None
+                oTheme = (
+                    Section.THEMES[oSec.theme] if oSec is not None else Section.EMPTY
+                )
+
+                if self.groupType == BarGroupType.LEFT:
+                    if s == 0:
+                        parts.append(BarGroup.bgColor(theme[1]))
+                    parts.append(BarGroup.fgColor(theme[0]))
+                    parts.append(sec)
+                    if theme == oTheme:
+                        parts.append("")
+                    else:
+                        parts.append(BarGroup.color(theme[1], oTheme[1]) + "")
+                else:
+                    if theme is oTheme:
+                        parts.append("")
+                    else:
+                        parts.append(BarGroup.fgColor(theme[1]) + "")
+                        parts.append(BarGroup.color(*theme))
+                    parts.append(sec)
+
+            # TODO OPTI Concatenate successive strings
+            self.parts = parts
+
+        if self.childsTextChanged or self.childsThemeChanged:
+            self.string = ""
+            for part in self.parts:
+                if isinstance(part, str):
+                    self.string += part
+                elif isinstance(part, Section):
+                    self.string += part.curText
+
+            self.parent.childsChanged = True
+
+            self.childsThemeChanged = False
+            self.childsTextChanged = False
+
+    @staticmethod
+    def updateAll():
+        for group in BarGroup.everyone:
+            group.update()
+        Bar.updateAll()
+
+
+class SectionThread(threading.Thread):
+    ANIMATION_START = 0.025
+    ANIMATION_STOP = 0.001
+    ANIMATION_EVOLUTION = 0.9
+
+    def run(self):
+        while Section.somethingChanged.wait():
+            notBusy.wait()
+            Section.updateAll()
+            animTime = self.ANIMATION_START
+            frameTime = time.perf_counter()
+            while len(Section.sizeChanging) > 0:
+                frameTime += animTime
+                curTime = time.perf_counter()
+                sleepTime = frameTime - curTime
+                time.sleep(sleepTime if sleepTime > 0 else 0)
+                Section.updateAll()
+                animTime *= self.ANIMATION_EVOLUTION
+                if animTime < self.ANIMATION_STOP:
+                    animTime = self.ANIMATION_STOP
+
+
+class Section:
+    # TODO Update all of that to base16
+    # COLORS = ['#272822', '#383830', '#49483e', '#75715e', '#a59f85', '#f8f8f2',
+    #           '#f5f4f1', '#f9f8f5', '#f92672', '#fd971f', '#f4bf75', '#a6e22e',
+    #           '#a1efe4', '#66d9ef', '#ae81ff', '#cc6633']
+    COLORS = [
+        "#181818",
+        "#AB4642",
+        "#A1B56C",
+        "#F7CA88",
+        "#7CAFC2",
+        "#BA8BAF",
+        "#86C1B9",
+        "#D8D8D8",
+        "#585858",
+        "#AB4642",
+        "#A1B56C",
+        "#F7CA88",
+        "#7CAFC2",
+        "#BA8BAF",
+        "#86C1B9",
+        "#F8F8F8",
+    ]
+    FGCOLOR = "#F8F8F2"
+    BGCOLOR = "#272822"
+
+    THEMES = list()
+    EMPTY = (FGCOLOR, BGCOLOR)
+
+    ICON = None
+    PERSISTENT = False
+
+    #: Sections that do not have their destination size
+    sizeChanging = set()
+    updateThread = SectionThread(daemon=True)
+    somethingChanged = threading.Event()
+    lastChosenTheme = 0
+
+    @staticmethod
+    def init():
+        for t in range(8, 16):
+            Section.THEMES.append((Section.COLORS[0], Section.COLORS[t]))
+
+        Section.updateThread.start()
+
+    def __init__(self, theme=None):
+        #: Displayed section
+        #: Note: A section can be empty and displayed!
+        self.visible = False
+
+        if theme is None:
+            theme = Section.lastChosenTheme
+            Section.lastChosenTheme = (Section.lastChosenTheme + 1) % len(
+                Section.THEMES
+            )
+        self.theme = theme
+
+        #: Displayed text
+        self.curText = ""
+        #: Displayed text size
+        self.curSize = 0
+
+        #: Destination text
+        self.dstText = Text(" ", Text(), " ")
+        #: Destination size
+        self.dstSize = 0
+
+        #: Groups that have this section
+        self.parents = set()
+
+        self.icon = self.ICON
+        self.persistent = self.PERSISTENT
+
+    def __str__(self):
+        try:
+            return "<{}><{}>{:01d}{}{:02d}/{:02d}".format(
+                self.curText,
+                self.dstText,
+                self.theme,
+                "+" if self.visible else "-",
+                self.curSize,
+                self.dstSize,
+            )
+        except:
+            return super().__str__()
+
+    def addParent(self, parent):
+        self.parents.add(parent)
+
+    def appendAfter(self, section):
+        assert len(self.parents)
+        for parent in self.parents:
+            parent.addSectionAfter(self, section)
+
+    def informParentsThemeChanged(self):
+        for parent in self.parents:
+            parent.childsThemeChanged = True
+
+    def informParentsTextChanged(self):
+        for parent in self.parents:
+            parent.childsTextChanged = True
+
+    def updateText(self, text):
+        if isinstance(text, str):
+            text = Text(text)
+        elif isinstance(text, Text) and not len(text.elements):
+            text = None
+
+        self.dstText[0] = (
+            None
+            if (text is None and not self.persistent)
+            else ((" " + self.icon + " ") if self.icon else " ")
+        )
+        self.dstText[1] = text
+        self.dstText[2] = (
+            " " if self.dstText[1] is not None and len(self.dstText[1]) else None
+        )
+
+        self.dstSize = len(self.dstText)
+        self.dstText.setSection(self)
+
+        if self.curSize == self.dstSize:
+            if self.dstSize > 0:
+                self.curText = str(self.dstText)
+                self.informParentsTextChanged()
+        else:
+            Section.sizeChanging.add(self)
+        Section.somethingChanged.set()
+
+    def setDecorators(self, **kwargs):
+        self.dstText.setDecorators(**kwargs)
+        self.curText = str(self.dstText)
+        self.informParentsTextChanged()
+        Section.somethingChanged.set()
+
+    def updateTheme(self, theme):
+        assert isinstance(theme, int)
+        assert theme < len(Section.THEMES)
+        if theme == self.theme:
+            return
+        self.theme = theme
+        self.informParentsThemeChanged()
+        Section.somethingChanged.set()
+
+    def updateVisibility(self, visibility):
+        assert isinstance(visibility, bool)
+
+        self.visible = visibility
+        self.informParentsThemeChanged()
+        Section.somethingChanged.set()
+
+    @staticmethod
+    def fit(text, size):
+        t = len(text)
+        return text[:size] if t >= size else text + [" "] * (size - t)
+
+    def update(self):
+        # TODO Might profit of a better logic
+        if not self.visible:
+            self.updateVisibility(True)
+            return
+
+        if self.dstSize > self.curSize:
+            self.curSize += 1
+        elif self.dstSize < self.curSize:
+            self.curSize -= 1
+        else:
+            # Visibility toggling must be done one step after curSize = 0
+            if self.dstSize == 0:
+                self.updateVisibility(False)
+            Section.sizeChanging.remove(self)
+            return
+
+        self.curText = self.dstText.text(size=self.curSize, pad=True)
+        self.informParentsTextChanged()
+
+    @staticmethod
+    def updateAll():
+        """
+        Process all sections for text size changes
+        """
+
+        for sizeChanging in Section.sizeChanging.copy():
+            sizeChanging.update()
+
+        BarGroup.updateAll()
+
+        Section.somethingChanged.clear()
+
+    @staticmethod
+    def ramp(p, ramp=" ▁▂▃▄▅▆▇█"):
+        if p > 1:
+            return ramp[-1]
+        elif p < 0:
+            return ramp[0]
+        else:
+            return ramp[round(p * (len(ramp) - 1))]
+
+
+class StatefulSection(Section):
+    # TODO FEAT Allow to temporary expand the section (e.g. when important change)
+    NUMBER_STATES = None
+    DEFAULT_STATE = 0
+
+    def __init__(self, *args, **kwargs):
+        Section.__init__(self, *args, **kwargs)
+        self.state = self.DEFAULT_STATE
+        if hasattr(self, "onChangeState"):
+            self.onChangeState(self.state)
+        self.setDecorators(
+            clickLeft=self.incrementState, clickRight=self.decrementState
+        )
+
+    def incrementState(self):
+        newState = min(self.state + 1, self.NUMBER_STATES - 1)
+        self.changeState(newState)
+
+    def decrementState(self):
+        newState = max(self.state - 1, 0)
+        self.changeState(newState)
+
+    def changeState(self, state):
+        assert isinstance(state, int)
+        assert state < self.NUMBER_STATES
+        self.state = state
+        if hasattr(self, "onChangeState"):
+            self.onChangeState(state)
+        self.refreshData()
+
+
+class ColorCountsSection(StatefulSection):
+    # TODO FEAT Blend colors when not expanded
+    # TODO FEAT Blend colors with importance of count
+    # TODO FEAT Allow icons instead of counts
+    NUMBER_STATES = 3
+    COLORABLE_ICON = "?"
+
+    def __init__(self, theme=None):
+        StatefulSection.__init__(self, theme=theme)
+
+    def fetcher(self):
+        counts = self.subfetcher()
+        # Nothing
+        if not len(counts):
+            return None
+        # Icon colored
+        elif self.state == 0 and len(counts) == 1:
+            count, color = counts[0]
+            return Text(self.COLORABLE_ICON, fg=color)
+        # Icon
+        elif self.state == 0 and len(counts) > 1:
+            return Text(self.COLORABLE_ICON)
+        # Icon + Total
+        elif self.state == 1 and len(counts) > 1:
+            total = sum([count for count, color in counts])
+            return Text(self.COLORABLE_ICON, " ", total)
+        # Icon + Counts
+        else:
+            text = Text(self.COLORABLE_ICON)
+            for count, color in counts:
+                text.append(" ", Text(count, fg=color))
+            return text
+
+
+class Text:
+    def _setElements(self, elements):
+        # TODO OPTI Concatenate consecutrive string
+        self.elements = list(elements)
+
+    def _setDecorators(self, decorators):
+        # TODO OPTI Convert no decorator to strings
+        self.decorators = decorators
+        self.prefix = None
+        self.suffix = None
+
+    def __init__(self, *args, **kwargs):
+        self._setElements(args)
+        self._setDecorators(kwargs)
+        self.section = None
+
+    def append(self, *args):
+        self._setElements(self.elements + list(args))
+
+    def prepend(self, *args):
+        self._setElements(list(args) + self.elements)
+
+    def setElements(self, *args):
+        self._setElements(args)
+
+    def setDecorators(self, **kwargs):
+        self._setDecorators(kwargs)
+
+    def setSection(self, section):
+        assert isinstance(section, Section)
+        self.section = section
+        for element in self.elements:
+            if isinstance(element, Text):
+                element.setSection(section)
+
+    def _genFixs(self):
+        if self.prefix is not None and self.suffix is not None:
+            return
+
+        self.prefix = ""
+        self.suffix = ""
+
+        def nest(prefix, suffix):
+            self.prefix = self.prefix + "%{" + prefix + "}"
+            self.suffix = "%{" + suffix + "}" + self.suffix
+
+        def getColor(val):
+            # TODO Allow themes
+            assert isinstance(val, str) and len(val) == 7
+            return val
+
+        def button(number, function):
+            handle = Bar.getFunctionHandle(function)
+            nest("A" + number + ":" + handle.decode() + ":", "A" + number)
+
+        for key, val in self.decorators.items():
+            if val is None:
+                continue
+            if key == "fg":
+                reset = self.section.THEMES[self.section.theme][0]
+                nest("F" + getColor(val), "F" + reset)
+            elif key == "bg":
+                reset = self.section.THEMES[self.section.theme][1]
+                nest("B" + getColor(val), "B" + reset)
+            elif key == "clickLeft":
+                button("1", val)
+            elif key == "clickMiddle":
+                button("2", val)
+            elif key == "clickRight":
+                button("3", val)
+            elif key == "scrollUp":
+                button("4", val)
+            elif key == "scrollDown":
+                button("5", val)
+            else:
+                log.warn("Unkown decorator: {}".format(key))
+
+    def _text(self, size=None, pad=False):
+        self._genFixs()
+        curString = self.prefix
+        curSize = 0
+        remSize = size
+
+        for element in self.elements:
+            if element is None:
+                continue
+            elif isinstance(element, Text):
+                newString, newSize = element._text(size=remSize)
+            else:
+                newString = str(element)
+                if remSize is not None:
+                    newString = newString[:remSize]
+                newSize = len(newString)
+
+            curString += newString
+            curSize += newSize
+
+            if remSize is not None:
+                remSize -= newSize
+                if remSize <= 0:
+                    break
+
+        curString += self.suffix
+
+        if pad and remSize > 0:
+            curString += " " * remSize
+            curSize += remSize
+
+        if size is not None:
+            if pad:
+                assert size == curSize
+            else:
+                assert size >= curSize
+        return curString, curSize
+
+    def text(self, *args, **kwargs):
+        string, size = self._text(*args, **kwargs)
+        return string
+
+    def __str__(self):
+        self._genFixs()
+        curString = self.prefix
+        for element in self.elements:
+            if element is None:
+                continue
+            else:
+                curString += str(element)
+        curString += self.suffix
+        return curString
+
+    def __len__(self):
+        curSize = 0
+        for element in self.elements:
+            if element is None:
+                continue
+            elif isinstance(element, Text):
+                curSize += len(element)
+            else:
+                curSize += len(str(element))
+        return curSize
+
+    def __getitem__(self, index):
+        return self.elements[index]
+
+    def __setitem__(self, index, data):
+        self.elements[index] = data

hm/desktop/frobar/frobar/notbusy.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+
+import threading
+
+notBusy = threading.Event()

hm/desktop/frobar/frobar/providers.py

@@ -0,0 +1,816 @@
+#!/usr/bin/env python3
+
+import datetime
+import ipaddress
+import json
+import logging
+import random
+import socket
+import subprocess
+
+import coloredlogs
+import mpd
+import notmuch
+import psutil
+import pulsectl
+
+from frobar.display import *
+from frobar.updaters import *
+
+coloredlogs.install(level="DEBUG", fmt="%(levelname)s %(message)s")
+log = logging.getLogger()
+
+# TODO Generator class (for I3WorkspacesProvider, NetworkProvider and later
+# PulseaudioProvider and MpdProvider)
+
+
+def humanSize(num):
+    """
+    Returns a string of width 3+3
+    """
+    for unit in ("B  ", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"):
+        if abs(num) < 1000:
+            if num >= 10:
+                return "{:3d}{}".format(int(num), unit)
+            else:
+                return "{:.1f}{}".format(num, unit)
+        num /= 1024.0
+    return "{:d}YiB".format(num)
+
+
+def randomColor(seed=0):
+    random.seed(seed)
+    return "#{:02x}{:02x}{:02x}".format(*[random.randint(0, 255) for _ in range(3)])
+
+
+class TimeProvider(StatefulSection, PeriodicUpdater):
+    FORMATS = ["%H:%M", "%m-%d %H:%M:%S", "%a %y-%m-%d %H:%M:%S"]
+    NUMBER_STATES = len(FORMATS)
+    DEFAULT_STATE = 1
+
+    def fetcher(self):
+        now = datetime.datetime.now()
+        return now.strftime(self.FORMATS[self.state])
+
+    def __init__(self, theme=None):
+        PeriodicUpdater.__init__(self)
+        StatefulSection.__init__(self, theme)
+        self.changeInterval(1)  # TODO OPTI When state < 1
+
+
+class AlertLevel(enum.Enum):
+    NORMAL = 0
+    WARNING = 1
+    DANGER = 2
+
+
+class AlertingSection(StatefulSection):
+    # TODO EASE Correct settings for themes
+    THEMES = {AlertLevel.NORMAL: 2, AlertLevel.WARNING: 3, AlertLevel.DANGER: 1}
+    PERSISTENT = True
+
+    def getLevel(self, quantity):
+        if quantity > self.dangerThresold:
+            return AlertLevel.DANGER
+        elif quantity > self.warningThresold:
+            return AlertLevel.WARNING
+        else:
+            return AlertLevel.NORMAL
+
+    def updateLevel(self, quantity):
+        self.level = self.getLevel(quantity)
+        self.updateTheme(self.THEMES[self.level])
+        if self.level == AlertLevel.NORMAL:
+            return
+        # TODO Temporary update state
+
+    def __init__(self, theme):
+        StatefulSection.__init__(self, theme)
+        self.dangerThresold = 0.90
+        self.warningThresold = 0.75
+
+
+class CpuProvider(AlertingSection, PeriodicUpdater):
+    NUMBER_STATES = 3
+    ICON = ""
+
+    def fetcher(self):
+        percent = psutil.cpu_percent(percpu=False)
+        self.updateLevel(percent / 100)
+        if self.state >= 2:
+            percents = psutil.cpu_percent(percpu=True)
+            return "".join([Section.ramp(p / 100) for p in percents])
+        elif self.state >= 1:
+            return Section.ramp(percent / 100)
+
+    def __init__(self, theme=None):
+        AlertingSection.__init__(self, theme)
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(1)
+
+
+class RamProvider(AlertingSection, PeriodicUpdater):
+    """
+    Shows free RAM
+    """
+
+    NUMBER_STATES = 4
+    ICON = ""
+
+    def fetcher(self):
+        mem = psutil.virtual_memory()
+        freePerc = mem.percent / 100
+        self.updateLevel(freePerc)
+
+        if self.state < 1:
+            return None
+
+        text = Text(Section.ramp(freePerc))
+        if self.state >= 2:
+            freeStr = humanSize(mem.total - mem.available)
+            text.append(freeStr)
+        if self.state >= 3:
+            totalStr = humanSize(mem.total)
+            text.append("/", totalStr)
+
+        return text
+
+    def __init__(self, theme=None):
+        AlertingSection.__init__(self, theme)
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(1)
+
+
+class TemperatureProvider(AlertingSection, PeriodicUpdater):
+    NUMBER_STATES = 2
+    RAMP = ""
+
+    def fetcher(self):
+        allTemp = psutil.sensors_temperatures()
+        if "coretemp" not in allTemp:
+            # TODO Opti Remove interval
+            return ""
+        temp = allTemp["coretemp"][0]
+
+        self.warningThresold = temp.high
+        self.dangerThresold = temp.critical
+        self.updateLevel(temp.current)
+
+        self.icon = Section.ramp(temp.current / temp.high, self.RAMP)
+        if self.state >= 1:
+            return "{:.0f}°C".format(temp.current)
+
+    def __init__(self, theme=None):
+        AlertingSection.__init__(self, theme)
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(5)
+
+
+class BatteryProvider(AlertingSection, PeriodicUpdater):
+    # TODO Support ACPID for events
+    NUMBER_STATES = 3
+    RAMP = ""
+
+    def fetcher(self):
+        bat = psutil.sensors_battery()
+        if not bat:
+            self.icon = None
+            return None
+
+        self.icon = ("" if bat.power_plugged else "") + Section.ramp(
+            bat.percent / 100, self.RAMP
+        )
+
+        self.updateLevel(1 - bat.percent / 100)
+
+        if self.state < 1:
+            return
+
+        t = Text("{:.0f}%".format(bat.percent))
+
+        if self.state < 2:
+            return t
+
+        h = int(bat.secsleft / 3600)
+        m = int((bat.secsleft - h * 3600) / 60)
+        t.append(" ({:d}:{:02d})".format(h, m))
+        return t
+
+    def __init__(self, theme=None):
+        AlertingSection.__init__(self, theme)
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(5)
+
+
+class PulseaudioProvider(StatefulSection, ThreadedUpdater):
+    NUMBER_STATES = 3
+    DEFAULT_STATE = 1
+
+    def __init__(self, theme=None):
+        ThreadedUpdater.__init__(self)
+        StatefulSection.__init__(self, theme)
+        self.pulseEvents = pulsectl.Pulse("event-handler")
+
+        self.pulseEvents.event_mask_set(pulsectl.PulseEventMaskEnum.sink)
+        self.pulseEvents.event_callback_set(self.handleEvent)
+        self.start()
+        self.refreshData()
+
+    def fetcher(self):
+        sinks = []
+        with pulsectl.Pulse("list-sinks") as pulse:
+            for sink in pulse.sink_list():
+                if sink.port_active.name == "analog-output-headphones":
+                    icon = ""
+                elif sink.port_active.name == "analog-output-speaker":
+                    icon = "" if sink.mute else ""
+                elif sink.port_active.name == "headset-output":
+                    icon = ""
+                else:
+                    icon = "?"
+                vol = pulse.volume_get_all_chans(sink)
+                fg = (sink.mute and "#333333") or (vol > 1 and "#FF0000") or None
+
+                t = Text(icon, fg=fg)
+                sinks.append(t)
+
+                if self.state < 1:
+                    continue
+
+                if self.state < 2:
+                    if not sink.mute:
+                        ramp = " "
+                        while vol >= 0:
+                            ramp += self.ramp(vol if vol < 1 else 1)
+                            vol -= 1
+                        t.append(ramp)
+                else:
+                    t.append(" {:2.0f}%".format(vol * 100))
+
+        return Text(*sinks)
+
+    def loop(self):
+        self.pulseEvents.event_listen()
+
+    def handleEvent(self, ev):
+        self.refreshData()
+
+
+class NetworkProviderSection(StatefulSection, Updater):
+    NUMBER_STATES = 5
+    DEFAULT_STATE = 1
+
+    def actType(self):
+        self.ssid = None
+        if self.iface.startswith("eth") or self.iface.startswith("enp"):
+            if "u" in self.iface:
+                self.icon = ""
+            else:
+                self.icon = ""
+        elif self.iface.startswith("wlan") or self.iface.startswith("wl"):
+            self.icon = ""
+            if self.showSsid:
+                cmd = ["iwgetid", self.iface, "--raw"]
+                p = subprocess.run(cmd, stdout=subprocess.PIPE)
+                self.ssid = p.stdout.strip().decode()
+        elif self.iface.startswith("tun") or self.iface.startswith("tap"):
+            self.icon = ""
+        elif self.iface.startswith("docker"):
+            self.icon = ""
+        elif self.iface.startswith("veth"):
+            self.icon = ""
+        elif self.iface.startswith("vboxnet"):
+            self.icon = ""
+        else:
+            self.icon = "?"
+
+    def getAddresses(self):
+        ipv4 = None
+        ipv6 = None
+        for address in self.parent.addrs[self.iface]:
+            if address.family == socket.AF_INET:
+                ipv4 = address
+            elif address.family == socket.AF_INET6:
+                ipv6 = address
+        return ipv4, ipv6
+
+    def fetcher(self):
+        self.icon = None
+        self.persistent = False
+        if (
+            self.iface not in self.parent.stats
+            or not self.parent.stats[self.iface].isup
+            or self.iface.startswith("lo")
+        ):
+            return None
+
+        # Get addresses
+        ipv4, ipv6 = self.getAddresses()
+        if ipv4 is None and ipv6 is None:
+            return None
+
+        text = []
+        self.persistent = True
+        self.actType()
+
+        if self.showSsid and self.ssid:
+            text.append(self.ssid)
+
+        if self.showAddress:
+            if ipv4:
+                netStrFull = "{}/{}".format(ipv4.address, ipv4.netmask)
+                addr = ipaddress.IPv4Network(netStrFull, strict=False)
+                addrStr = "{}/{}".format(ipv4.address, addr.prefixlen)
+                text.append(addrStr)
+            # TODO IPV6
+            # if ipv6:
+            #     text += ' ' + ipv6.address
+
+        if self.showSpeed:
+            recvDiff = (
+                self.parent.IO[self.iface].bytes_recv
+                - self.parent.prevIO[self.iface].bytes_recv
+            )
+            sentDiff = (
+                self.parent.IO[self.iface].bytes_sent
+                - self.parent.prevIO[self.iface].bytes_sent
+            )
+            recvDiff /= self.parent.dt
+            sentDiff /= self.parent.dt
+            text.append("↓{}↑{}".format(humanSize(recvDiff), humanSize(sentDiff)))
+
+        if self.showTransfer:
+            text.append(
+                "⇓{}⇑{}".format(
+                    humanSize(self.parent.IO[self.iface].bytes_recv),
+                    humanSize(self.parent.IO[self.iface].bytes_sent),
+                )
+            )
+
+        return " ".join(text)
+
+    def onChangeState(self, state):
+        self.showSsid = state >= 1
+        self.showAddress = state >= 2
+        self.showSpeed = state >= 3
+        self.showTransfer = state >= 4
+
+    def __init__(self, iface, parent):
+        Updater.__init__(self)
+        StatefulSection.__init__(self, theme=parent.theme)
+        self.iface = iface
+        self.parent = parent
+
+
+class NetworkProvider(Section, PeriodicUpdater):
+    def fetchData(self):
+        self.prev = self.last
+        self.prevIO = self.IO
+
+        self.stats = psutil.net_if_stats()
+        self.addrs = psutil.net_if_addrs()
+        self.IO = psutil.net_io_counters(pernic=True)
+        self.ifaces = self.stats.keys()
+
+        self.last = time.perf_counter()
+        self.dt = self.last - self.prev
+
+    def fetcher(self):
+        self.fetchData()
+
+        # Add missing sections
+        lastSection = self
+        for iface in sorted(list(self.ifaces)):
+            if iface not in self.sections.keys():
+                section = NetworkProviderSection(iface, self)
+                lastSection.appendAfter(section)
+                self.sections[iface] = section
+            else:
+                section = self.sections[iface]
+            lastSection = section
+
+        # Refresh section text
+        for section in self.sections.values():
+            section.refreshData()
+
+        return None
+
+    def addParent(self, parent):
+        self.parents.add(parent)
+        self.refreshData()
+
+    def __init__(self, theme=None):
+        PeriodicUpdater.__init__(self)
+        Section.__init__(self, theme)
+
+        self.sections = dict()
+        self.last = 0
+        self.IO = dict()
+        self.fetchData()
+        self.changeInterval(5)
+
+
+class RfkillProvider(Section, PeriodicUpdater):
+    # TODO FEAT rfkill doesn't seem to indicate that the hardware switch is
+    # toggled
+    PATH = "/sys/class/rfkill"
+
+    def fetcher(self):
+        t = Text()
+        for device in os.listdir(self.PATH):
+            with open(os.path.join(self.PATH, device, "soft"), "rb") as f:
+                softBlocked = f.read().strip() != b"0"
+            with open(os.path.join(self.PATH, device, "hard"), "rb") as f:
+                hardBlocked = f.read().strip() != b"0"
+
+            if not hardBlocked and not softBlocked:
+                continue
+
+            with open(os.path.join(self.PATH, device, "type"), "rb") as f:
+                typ = f.read().strip()
+
+            fg = (hardBlocked and "#CCCCCC") or (softBlocked and "#FF0000")
+            if typ == b"wlan":
+                icon = ""
+            elif typ == b"bluetooth":
+                icon = ""
+            else:
+                icon = "?"
+
+            t.append(Text(icon, fg=fg))
+        return t
+
+    def __init__(self, theme=None):
+        PeriodicUpdater.__init__(self)
+        Section.__init__(self, theme)
+        self.changeInterval(5)
+
+
+class SshAgentProvider(PeriodicUpdater):
+    def fetcher(self):
+        cmd = ["ssh-add", "-l"]
+        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+        if proc.returncode != 0:
+            return None
+        text = Text()
+        for line in proc.stdout.split(b"\n"):
+            if not len(line):
+                continue
+            fingerprint = line.split()[1]
+            text.append(Text("", fg=randomColor(seed=fingerprint)))
+        return text
+
+    def __init__(self):
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(5)
+
+
+class GpgAgentProvider(PeriodicUpdater):
+    def fetcher(self):
+        cmd = ["gpg-connect-agent", "keyinfo --list", "/bye"]
+        proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+        # proc = subprocess.run(cmd)
+        if proc.returncode != 0:
+            return None
+        text = Text()
+        for line in proc.stdout.split(b"\n"):
+            if not len(line) or line == b"OK":
+                continue
+            spli = line.split()
+            if spli[6] != b"1":
+                continue
+            keygrip = spli[2]
+            text.append(Text("", fg=randomColor(seed=keygrip)))
+        return text
+
+    def __init__(self):
+        PeriodicUpdater.__init__(self)
+        self.changeInterval(5)
+
+
+class KeystoreProvider(Section, MergedUpdater):
+    # TODO OPTI+FEAT Use ColorCountsSection and not MergedUpdater, this is useless
+    ICON = ""
+
+    def __init__(self, theme=None):
+        MergedUpdater.__init__(self, SshAgentProvider(), GpgAgentProvider())
+        Section.__init__(self, theme)
+
+
+class NotmuchUnreadProvider(ColorCountsSection, InotifyUpdater):
+    COLORABLE_ICON = ""
+
+    def subfetcher(self):
+        db = notmuch.Database(mode=notmuch.Database.MODE.READ_ONLY, path=self.dir)
+        counts = []
+        for account in self.accounts:
+            queryStr = "folder:/{}/ and tag:unread".format(account)
+            query = notmuch.Query(db, queryStr)
+            nbMsgs = query.count_messages()
+            if account == "frogeye":
+                global q
+                q = query
+            if nbMsgs < 1:
+                continue
+            counts.append((nbMsgs, self.colors[account]))
+        # db.close()
+        return counts
+
+    def __init__(self, dir="~/.mail/", theme=None):
+        PeriodicUpdater.__init__(self)
+        ColorCountsSection.__init__(self, theme)
+
+        self.dir = os.path.realpath(os.path.expanduser(dir))
+        assert os.path.isdir(self.dir)
+
+        # Fetching account list
+        self.accounts = sorted(
+            [a for a in os.listdir(self.dir) if not a.startswith(".")]
+        )
+        # Fetching colors
+        self.colors = dict()
+        for account in self.accounts:
+            filename = os.path.join(self.dir, account, "color")
+            with open(filename, "r") as f:
+                color = f.read().strip()
+            self.colors[account] = color
+
+        self.addPath(os.path.join(self.dir, ".notmuch", "xapian"))
+
+
+class TodoProvider(ColorCountsSection, InotifyUpdater):
+    # TODO OPT/UX Maybe we could get more data from the todoman python module
+    # TODO OPT Specific callback for specific directory
+    COLORABLE_ICON = ""
+
+    def updateCalendarList(self):
+        calendars = sorted(os.listdir(self.dir))
+        for calendar in calendars:
+            # If the calendar wasn't in the list
+            if calendar not in self.calendars:
+                self.addPath(os.path.join(self.dir, calendar), refresh=False)
+
+                # Fetching name
+                path = os.path.join(self.dir, calendar, "displayname")
+                with open(path, "r") as f:
+                    self.names[calendar] = f.read().strip()
+
+                # Fetching color
+                path = os.path.join(self.dir, calendar, "color")
+                with open(path, "r") as f:
+                    self.colors[calendar] = f.read().strip()
+        self.calendars = calendars
+
+    def __init__(self, dir, theme=None):
+        """
+        :parm str dir: [main]path value in todoman.conf
+        """
+        InotifyUpdater.__init__(self)
+        ColorCountsSection.__init__(self, theme=theme)
+        self.dir = os.path.realpath(os.path.expanduser(dir))
+        assert os.path.isdir(self.dir)
+
+        self.calendars = []
+        self.colors = dict()
+        self.names = dict()
+        self.updateCalendarList()
+        self.refreshData()
+
+    def countUndone(self, calendar):
+        cmd = ["todo", "--porcelain", "list"]
+        if calendar:
+            cmd.append(self.names[calendar])
+        proc = subprocess.run(cmd, stdout=subprocess.PIPE)
+        data = json.loads(proc.stdout)
+        return len(data)
+
+    def subfetcher(self):
+        counts = []
+
+        # TODO This an ugly optimisation that cuts on features, but todoman
+        # calls are very expensive so we keep that in the meanwhile
+        if self.state < 2:
+            c = self.countUndone(None)
+            if c > 0:
+                counts.append((c, "#00000"))
+                counts.append((0, "#FFFFF"))
+            return counts
+        # Optimisation ends here
+
+        for calendar in self.calendars:
+            c = self.countUndone(calendar)
+            if c <= 0:
+                continue
+            counts.append((c, self.colors[calendar]))
+        return counts
+
+
+class I3WindowTitleProvider(Section, I3Updater):
+    # TODO FEAT To make this available from start, we need to find the
+    # `focused=True` element following the `focus` array
+    # TODO Feat Make this output dependant if wanted
+    def on_window(self, i3, e):
+        self.updateText(e.container.name)
+
+    def __init__(self, theme=None):
+        I3Updater.__init__(self)
+        Section.__init__(self, theme=theme)
+        self.on("window", self.on_window)
+
+
+class I3WorkspacesProviderSection(Section):
+    def selectTheme(self):
+        if self.urgent:
+            return self.parent.themeUrgent
+        elif self.focused:
+            return self.parent.themeFocus
+        else:
+            return self.parent.themeNormal
+
+    # TODO On mode change the state (shown / hidden) gets overriden so every
+    # tab is shown
+
+    def show(self):
+        self.updateTheme(self.selectTheme())
+        self.updateText(self.fullName if self.focused else self.shortName)
+
+    def changeState(self, focused, urgent):
+        self.focused = focused
+        self.urgent = urgent
+        self.show()
+
+    def setName(self, name):
+        self.shortName = name
+        self.fullName = (
+            self.parent.customNames[name] if name in self.parent.customNames else name
+        )
+
+    def switchTo(self):
+        self.parent.i3.command("workspace {}".format(self.shortName))
+
+    def __init__(self, name, parent):
+        Section.__init__(self)
+        self.parent = parent
+        self.setName(name)
+        self.setDecorators(clickLeft=self.switchTo)
+        self.tempText = None
+
+    def empty(self):
+        self.updateTheme(self.parent.themeNormal)
+        self.updateText(None)
+
+    def tempShow(self):
+        self.updateText(self.tempText)
+
+    def tempEmpty(self):
+        self.tempText = self.dstText[1]
+        self.updateText(None)
+
+
+class I3WorkspacesProvider(Section, I3Updater):
+    # TODO FEAT Multi-screen
+
+    def initialPopulation(self, parent):
+        """
+        Called on init
+        Can't reuse addWorkspace since i3.get_workspaces() gives dict and not
+        ConObjects
+        """
+        workspaces = self.i3.get_workspaces()
+        lastSection = self.modeSection
+        for workspace in workspaces:
+            # if parent.display != workspace["display"]:
+            #     continue
+
+            section = I3WorkspacesProviderSection(workspace.name, self)
+            section.focused = workspace.focused
+            section.urgent = workspace.urgent
+            section.show()
+            parent.addSectionAfter(lastSection, section)
+            self.sections[workspace.num] = section
+
+            lastSection = section
+
+    def on_workspace_init(self, i3, e):
+        workspace = e.current
+        i = workspace.num
+        if i in self.sections:
+            section = self.sections[i]
+        else:
+            # Find the section just before
+            while i not in self.sections.keys() and i > 0:
+                i -= 1
+            prevSection = self.sections[i] if i != 0 else self.modeSection
+
+            section = I3WorkspacesProviderSection(workspace.name, self)
+            prevSection.appendAfter(section)
+            self.sections[workspace.num] = section
+        section.focused = workspace.focused
+        section.urgent = workspace.urgent
+        section.show()
+
+    def on_workspace_empty(self, i3, e):
+        self.sections[e.current.num].empty()
+
+    def on_workspace_focus(self, i3, e):
+        self.sections[e.old.num].focused = False
+        self.sections[e.old.num].show()
+        self.sections[e.current.num].focused = True
+        self.sections[e.current.num].show()
+
+    def on_workspace_urgent(self, i3, e):
+        self.sections[e.current.num].urgent = e.current.urgent
+        self.sections[e.current.num].show()
+
+    def on_workspace_rename(self, i3, e):
+        self.sections[e.current.num].setName(e.name)
+        self.sections[e.current.num].show()
+
+    def on_mode(self, i3, e):
+        if e.change == "default":
+            self.modeSection.updateText(None)
+            for section in self.sections.values():
+                section.tempShow()
+        else:
+            self.modeSection.updateText(e.change)
+            for section in self.sections.values():
+                section.tempEmpty()
+
+    def __init__(
+        self, theme=0, themeFocus=3, themeUrgent=1, themeMode=2, customNames=dict()
+    ):
+        I3Updater.__init__(self)
+        Section.__init__(self)
+        self.themeNormal = theme
+        self.themeFocus = themeFocus
+        self.themeUrgent = themeUrgent
+        self.customNames = customNames
+
+        self.sections = dict()
+        self.on("workspace::init", self.on_workspace_init)
+        self.on("workspace::focus", self.on_workspace_focus)
+        self.on("workspace::empty", self.on_workspace_empty)
+        self.on("workspace::urgent", self.on_workspace_urgent)
+        self.on("workspace::rename", self.on_workspace_rename)
+        # TODO Un-handled/tested: reload, rename, restored, move
+
+        self.on("mode", self.on_mode)
+        self.modeSection = Section(theme=themeMode)
+
+    def addParent(self, parent):
+        self.parents.add(parent)
+        parent.addSection(self.modeSection)
+        self.initialPopulation(parent)
+
+
+class MpdProvider(Section, ThreadedUpdater):
+    # TODO FEAT More informations and controls
+
+    MAX_LENGTH = 50
+
+    def connect(self):
+        self.mpd.connect("localhost", 6600)
+
+    def __init__(self, theme=None):
+        ThreadedUpdater.__init__(self)
+        Section.__init__(self, theme)
+
+        self.mpd = mpd.MPDClient()
+        self.connect()
+        self.refreshData()
+        self.start()
+
+    def fetcher(self):
+        stat = self.mpd.status()
+        if not len(stat) or stat["state"] == "stop":
+            return None
+
+        cur = self.mpd.currentsong()
+        if not len(cur):
+            return None
+
+        infos = []
+
+        def tryAdd(field):
+            if field in cur:
+                infos.append(cur[field])
+
+        tryAdd("title")
+        tryAdd("album")
+        tryAdd("artist")
+
+        infosStr = " - ".join(infos)
+        if len(infosStr) > MpdProvider.MAX_LENGTH:
+            infosStr = infosStr[: MpdProvider.MAX_LENGTH - 1] + "…"
+
+        return " {}".format(infosStr)
+
+    def loop(self):
+        try:
+            self.mpd.idle("player")
+            self.refreshData()
+        except mpd.base.ConnectionError as e:
+            log.warn(e, exc_info=True)
+            self.connect()
+        except BaseException as e:
+            log.error(e, exc_info=True)

hm/desktop/frobar/frobar/updaters.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+
+import functools
+import logging
+import math
+import os
+import threading
+import time
+
+import coloredlogs
+import i3ipc
+import pyinotify
+
+from frobar.display import Text
+from frobar.notbusy import notBusy
+
+coloredlogs.install(level="DEBUG", fmt="%(levelname)s %(message)s")
+log = logging.getLogger()
+
+# TODO Sync bar update with PeriodicUpdater updates
+
+
+
+class Updater:
+    @staticmethod
+    def init():
+        PeriodicUpdater.init()
+        InotifyUpdater.init()
+        notBusy.set()
+
+    def updateText(self, text):
+        print(text)
+
+    def fetcher(self):
+        return "{} refreshed".format(self)
+
+    def __init__(self):
+        self.lock = threading.Lock()
+
+    def refreshData(self):
+        # TODO OPTI Maybe discard the refresh if there's already another one?
+        self.lock.acquire()
+        try:
+            data = self.fetcher()
+        except BaseException as e:
+            log.error(e, exc_info=True)
+            data = ""
+        self.updateText(data)
+        self.lock.release()
+
+
+class PeriodicUpdaterThread(threading.Thread):
+    def run(self):
+        # TODO Sync with system clock
+        counter = 0
+        while True:
+            notBusy.set()
+            if PeriodicUpdater.intervalsChanged.wait(
+                timeout=PeriodicUpdater.intervalStep
+            ):
+                # ↑ sleeps here
+                notBusy.clear()
+                PeriodicUpdater.intervalsChanged.clear()
+                counter = 0
+                for providerList in PeriodicUpdater.intervals.copy().values():
+                    for provider in providerList.copy():
+                        provider.refreshData()
+            else:
+                notBusy.clear()
+                counter += PeriodicUpdater.intervalStep
+                counter = counter % PeriodicUpdater.intervalLoop
+                for interval in PeriodicUpdater.intervals.keys():
+                    if counter % interval == 0:
+                        for provider in PeriodicUpdater.intervals[interval]:
+                            provider.refreshData()
+
+
+class PeriodicUpdater(Updater):
+    """
+    Needs to call :func:`PeriodicUpdater.changeInterval` in `__init__`
+    """
+
+    intervals = dict()
+    intervalStep = None
+    intervalLoop = None
+    updateThread = PeriodicUpdaterThread(daemon=True)
+    intervalsChanged = threading.Event()
+
+    @staticmethod
+    def gcds(*args):
+        return functools.reduce(math.gcd, args)
+
+    @staticmethod
+    def lcm(a, b):
+        """Return lowest common multiple."""
+        return a * b // math.gcd(a, b)
+
+    @staticmethod
+    def lcms(*args):
+        """Return lowest common multiple."""
+        return functools.reduce(PeriodicUpdater.lcm, args)
+
+    @staticmethod
+    def updateIntervals():
+        intervalsList = list(PeriodicUpdater.intervals.keys())
+        PeriodicUpdater.intervalStep = PeriodicUpdater.gcds(*intervalsList)
+        PeriodicUpdater.intervalLoop = PeriodicUpdater.lcms(*intervalsList)
+        PeriodicUpdater.intervalsChanged.set()
+
+    @staticmethod
+    def init():
+        PeriodicUpdater.updateThread.start()
+
+    def __init__(self):
+        Updater.__init__(self)
+        self.interval = None
+
+    def changeInterval(self, interval):
+        assert isinstance(interval, int)
+
+        if self.interval is not None:
+            PeriodicUpdater.intervals[self.interval].remove(self)
+
+        self.interval = interval
+
+        if interval not in PeriodicUpdater.intervals:
+            PeriodicUpdater.intervals[interval] = set()
+        PeriodicUpdater.intervals[interval].add(self)
+
+        PeriodicUpdater.updateIntervals()
+
+
+class InotifyUpdaterEventHandler(pyinotify.ProcessEvent):
+    def process_default(self, event):
+        # DEBUG
+        # from pprint import pprint
+        # pprint(event.__dict__)
+        # return
+
+        assert event.path in InotifyUpdater.paths
+
+        if 0 in InotifyUpdater.paths[event.path]:
+            for provider in InotifyUpdater.paths[event.path][0]:
+                provider.refreshData()
+
+        if event.name in InotifyUpdater.paths[event.path]:
+            for provider in InotifyUpdater.paths[event.path][event.name]:
+                provider.refreshData()
+
+
+class InotifyUpdater(Updater):
+    """
+    Needs to call :func:`PeriodicUpdater.changeInterval` in `__init__`
+    """
+
+    wm = pyinotify.WatchManager()
+    paths = dict()
+
+    @staticmethod
+    def init():
+        notifier = pyinotify.ThreadedNotifier(
+            InotifyUpdater.wm, InotifyUpdaterEventHandler()
+        )
+        notifier.start()
+
+    # TODO Mask for folders
+    MASK = pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_DELETE
+
+    def addPath(self, path, refresh=True):
+        path = os.path.realpath(os.path.expanduser(path))
+
+        # Detect if file or folder
+        if os.path.isdir(path):
+            self.dirpath = path
+            # 0: Directory watcher
+            self.filename = 0
+        elif os.path.isfile(path):
+            self.dirpath = os.path.dirname(path)
+            self.filename = os.path.basename(path)
+        else:
+            raise FileNotFoundError("No such file or directory: '{}'".format(path))
+
+        # Register watch action
+        if self.dirpath not in InotifyUpdater.paths:
+            InotifyUpdater.paths[self.dirpath] = dict()
+        if self.filename not in InotifyUpdater.paths[self.dirpath]:
+            InotifyUpdater.paths[self.dirpath][self.filename] = set()
+        InotifyUpdater.paths[self.dirpath][self.filename].add(self)
+
+        # Add watch
+        InotifyUpdater.wm.add_watch(self.dirpath, InotifyUpdater.MASK)
+
+        if refresh:
+            self.refreshData()
+
+
+class ThreadedUpdaterThread(threading.Thread):
+    def __init__(self, updater, *args, **kwargs):
+        self.updater = updater
+        threading.Thread.__init__(self, *args, **kwargs)
+        self.looping = True
+
+    def run(self):
+        try:
+            while self.looping:
+                self.updater.loop()
+        except BaseException as e:
+            log.error("Error with {}".format(self.updater))
+            log.error(e, exc_info=True)
+            self.updater.updateText("")
+
+
+class ThreadedUpdater(Updater):
+    """
+    Must implement loop(), and call start()
+    """
+
+    def __init__(self):
+        Updater.__init__(self)
+        self.thread = ThreadedUpdaterThread(self, daemon=True)
+
+    def loop(self):
+        self.refreshData()
+        time.sleep(10)
+
+    def start(self):
+        self.thread.start()
+
+
+class I3Updater(ThreadedUpdater):
+    # TODO OPTI One i3 connection for all
+
+    def __init__(self):
+        ThreadedUpdater.__init__(self)
+        self.i3 = i3ipc.Connection()
+        self.start()
+
+    def on(self, event, function):
+        self.i3.on(event, function)
+
+    def loop(self):
+        self.i3.main()
+
+
+class MergedUpdater(Updater):
+    # TODO OPTI Do not update until end of periodic batch
+    def fetcher(self):
+        text = Text()
+        for updater in self.updaters:
+            text.append(self.texts[updater])
+        if not len(text):
+            return None
+        return text
+
+    def __init__(self, *args):
+        Updater.__init__(self)
+
+        self.updaters = []
+        self.texts = dict()
+
+        for updater in args:
+            assert isinstance(updater, Updater)
+
+            def newUpdateText(updater, text):
+                self.texts[updater] = text
+                self.refreshData()
+
+            updater.updateText = newUpdateText.__get__(updater, Updater)
+
+            self.updaters.append(updater)
+            self.texts[updater] = ""

hm/desktop/frobar/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup
+
+setup(
+    name="frobar",
+    version="2.0",
+    install_requires=[
+        "coloredlogs",
+        "notmuch",
+        "i3ipc",
+        "python-mpd2",
+        "psutil",
+        "pulsectl",
+        "pyinotify",
+    ],
+    entry_points={
+        "console_scripts": [
+            "frobar = frobar:run",
+        ]
+    },
+)