lemonbar: Breakout condition logic to Shelf class

.i3/lemonbar/i3_lemonbar_common.py

@@ -1,3 +1,4 @@
+import threading
 import subprocess, os
 import re # regexp
 from enum import Enum
@@ -48,3 +49,28 @@ def create_new_fifo(fifo_file):
         logger.error('''Failed, couldn't create fifo file''')
         os.remove(config.pid_file) # Clean up own PID file
         sys.exit(0)
+
+class Shelf():
+    # A one-slot queue implemented with locks and condition objects
+    def __init__(self, item = None):
+        self.lock            = threading.Lock()
+        self.item_ready = threading.Condition(self.lock)
+        self.item       = item
+
+    def get(self):
+        # Consumes item
+        self.item_ready.acquire()
+        if self.item is None:
+            # Wait until becomes ready
+            self.item_ready.wait()
+        ret = self.item
+        self.item = None
+        self.item_ready.release()
+        return ret
+
+    def put(self, item):
+        # Discards previous item
+        self.item_ready.acquire()
+        self.item = item
+        self.item_ready.notify()
+        self.item_ready.release()

.i3/lemonbar/i3_lemonbar_launcher.py

@@ -210,7 +210,7 @@ if __name__ == "__main__":
     common.health_logger = logging.getLogger('Health logger')
     common.health_logger.addHandler(handler)
 
-#    common.logger.basicConfig(stream=sys.stdout, level=debuglvl)
+    # Make sure no other instance running and ensure clean up on exit
     assert_only_instance() # Creates pid file and fifo file
     atexit.register(clean_up)
     signal.signal(signal.SIGTERM, handle_exit)

.i3/lemonbar/i3_lemonbar_modules.py

@@ -91,36 +91,22 @@ class DateTimeModule(LemonModule):
     def _start_module(self):
         class DateTimeThread(threading.Thread):
             def __init__(self, secs_mode = False):
-                self.secs_mode = secs_mode
+                self.secs_mode   = secs_mode
-                self.readline  = self.__readline_first
+                self.last_output = ''
-                self.output    = ''
 
-                lock              = threading.Lock()
+                self.shelf      = common.Shelf()
-                self.output_ready = threading.Condition(lock)
+                self.readline   = self.shelf.get
-                self.clock_tick   = threading.Condition(lock) # Needed, because sleep may be interrupted when user
+                self.clock_tick = threading.Condition(self.shelf.lock) # Needed, because sleep may be
-                                                              # changes H:M to H:M:S
+                                                                       # interrupted when user changes H:M to H:M:S
                 super().__init__()
 
-            def __readline_first(self):
-                # Should return instantly the first time
-                self.readline = self.__readline_blocking
-                return self.output
-
-            def __readline_blocking(self):
-                self.output_ready.acquire()
-                self.output_ready.wait()
-                self.output_ready.release()
-                return self.output
-
             def run(self):
                 while True:
                     fmt = "%a %d %b %H:%M:%S" if self.secs_mode else "%a %d %b %H:%M"
                     timestr = time.strftime(fmt, time.localtime())
-                    if timestr != self.output:
+                    if timestr != self.last_output:
-                        self.output = timestr
+                        self.last_output = timestr
-                        self.output_ready.acquire()
+                        self.shelf.put(timestr)
-                        self.output_ready.notify()
-                        self.output_ready.release()
                     self.sleep_until_change()
 
             def sleep_until_change(self):