multi cb'er and file-append based since file queues exist

poc/main.py

@@ -1,6 +1,30 @@
 from sys import stdin, stdout
+import signal
+from os import getpid, kill
 import time
 
+def main(stream):
+   bucket = None
+   N = 3
+   R = 2
+   T = 2
+   triggered = CBAppend("/tmp/cbappend.triggered.txt")
+   triggered = CBAppend("/tmp/cbappend.both.txt")
+   released = CBAppend("/tmp/cbappend.both.txt")
+   cb = CBFork(triggered, released)
+   bucket = Bucket(N, R, T, cb.cb())
+
+   while readline():
+      print("bucket.push():", bucket.push())
+      stdout.flush()
+
+def readline():
+   try:
+      line = input()
+      return True
+   except EOFError:
+      return False
+
 class Bucket:
    def __init__(self, N, R, T, CB):
       self.q = 0.0
@@ -36,7 +60,6 @@ class Bucket:
       if self.q+c > self.N:
          return False
       self.q += c
-      print(f"{int(self.q)} = + {int(c+.5)}")
       return True
 
    def __pop(self):
@@ -45,29 +68,52 @@ class Bucket:
       if remove_up_to > self.q:
          remove_up_to = self.q
       self.q -= remove_up_to
-      print(f"{int(self.q)} = - {int(remove_up_to+.5)}")
       self.__last_pop = now
 
    def __now(self):
       return time.time()
 
-def main(stream):
+class CBSignals():
-   bucket = None
+   def __init__(self, pid, signal_triggered, signal_released):
-   N = 3
+      self.__pid = pid
-   R = 2
+      self.__signal_triggered = signal_triggered
-   T = 1
+      self.__signal_released = signal_released
-   bucket = Bucket(N, R, T, lambda state: print(f"state is now {state} ({bucket.state()}), q={bucket.q}"))
 
-   while readline():
+   def cb(self):
-      bucket.push()
+      def cb(state):
-      stdout.flush()
+         print(f"state is now {state}")
+         kill(
+            self.__pid,
+            self.__signal_triggered if state else self.__signal_released,
+         )
+      handler = lambda s, f: print("SIGNAL:", s)
+      signal.signal(self.__signal_triggered, handler)
+      signal.signal(self.__signal_released, handler)
+      return cb
 
-def readline():
+class CBAppend():
-   try:
+   def __init__(self, path):
-      line = input()
+      self.__path = path
-      return True
+
-   except EOFError:
+   def cb(self):
-      return False
+      def cb(state):
+         with open(self.__path, "a") as f:
+            f.write(f"{state}\n")
+      return cb
+
+class CBFork():
+   def __init__(self, triggered, released):
+      self.__triggered = triggered
+      self.__released = released
+
+   def cb(self):
+      cb_triggered = self.__triggered.cb()
+      cb_released = self.__released.cb()
+      def cb(state):
+         if state:
+            return cb_triggered(state)
+         return cb_released(state)
+      return cb
 
 if __name__ == "__main__":
    main(stdin)