add py-ratio1024-log2 but log looks notsogood so its just ratio

poc/py-rps/requirements.txt

@@ -0,0 +1 @@
+pyautogui

poc/py-rps/state_to_buttons.py

@@ -0,0 +1,27 @@
+import argparse
+import os
+from time import sleep
+
+def main():
+   args = get_args()
+   buckets = {}
+   with open(args.p, "r") as f:
+      f.seek(0, os.SEEK_END)
+      while True:
+         line = f.readline().strip()
+         if not line:
+            sleep(0.25)
+            continue
+         key = line.strip("/").split()[0]
+         if not key in buckets:
+            buckets[key] = False
+         buckets[key] = False if line[0] == "/" else float(line.split()[-1])
+         print("[", " ".join(sorted([f"{int(i)}={buckets[i]}" for i in buckets if buckets[i]])), "]")
+
+def get_args():
+   ap = argparse.ArgumentParser()
+   ap.add_argument("-p", type=str, help="path to write out to", default="/tmp/cbappend.both.txt")
+   return ap.parse_args()
+
+if __name__ == "__main__":
+   main()

poc/py-rps/stream_to_state.py

@@ -0,0 +1,164 @@
+import signal
+from os import getpid, kill
+import time
+import argparse
+
+def main():
+   args = get_args()
+   with_(
+      N=args.n,
+      M=args.m,
+      R=args.r,
+      T=args.t,
+      p=args.p,
+   )
+
+def get_args():
+   ap = argparse.ArgumentParser()
+   ap.add_argument("-n", type=int, help="queue capacity", default=3)
+   ap.add_argument("-m", type=int, help="queue fill line", default=3)
+   ap.add_argument("-r", type=int, help="drain rate per second", default=2)
+   ap.add_argument("-t", type=int, help="threshold for state", default=2)
+   ap.add_argument("-p", type=str, help="path to write out to", default="/tmp/cbappend.both.txt")
+   return ap.parse_args()
+
+def with_(N, M, R, T, p):
+   triggered = CBAppend(p)
+   released = CBAppend(p)
+   cb = CBFork(triggered, released)
+
+   buckets = {}
+
+   while True:
+      got = readline()
+      if got:
+         if not got in buckets:
+            buckets[got] = Bucket(N, M, R, T, cb.cb(got))
+         buckets[got].push()
+      # TODO no /state
+      [buckets[i].pop() for i in buckets]
+
+def readline():
+   def __input(*args):
+      return input()
+   def _input(*args):
+      try:
+         foo = __input()
+      except Exception as e:
+         foo = None
+      return foo
+   timeout = 1
+   signal.signal(signal.SIGALRM, __input)
+   signal.alarm(timeout)
+   foo = _input()
+   return foo
+
+class State():
+   def __init__(self, active, f):
+      self.active = active
+      self.f = f
+
+class Bucket():
+   def __init__(self, N, M, R, T, CB):
+      self.q = 0.0
+      self.N = N
+      self.M = M
+      self.R = R
+      self.T = T
+      self.CB = CB
+      self.__last_pop = 0
+      self.__last_state = False
+
+   def push(self):
+      result = self.__push_c(1)
+      self.__cb()
+      return result
+
+   def pop(self):
+      result = self.__pop()
+      self.__cb()
+      return result
+
+   def __cb(self):
+      new_state = self.q > self.T
+      if new_state == self.__last_state:
+         return
+      self.__last_state = new_state
+      filledness = int(
+         100*(
+            max(
+               [self.q-self.T, 0]
+            )/max(
+               [self.M-self.T, 1]
+            )
+         )
+      )/100.0
+      if filledness > 1.0:
+         filledness = 1.0
+      self.CB(State(new_state, filledness))
+
+   def state(self):
+      return self.__last_state
+
+   def __push_c(self, c):
+      self.__pop()
+      if self.q+c > self.N:
+         return False
+      self.q += c
+      return True
+
+   def __pop(self):
+      now = self.__now()
+      remove_up_to = (now - self.__last_pop) / self.R
+      if remove_up_to > self.q:
+         remove_up_to = self.q
+      self.q -= remove_up_to
+      self.__last_pop = now
+
+   def __now(self):
+      return time.time()
+
+class CBSignals():
+   def __init__(self, pid, signal_triggered, signal_released):
+      self.__pid = pid
+      self.__signal_triggered = signal_triggered
+      self.__signal_released = signal_released
+
+   def cb(self, payload):
+      def cb(state):
+         print(f"state is now {state}")
+         kill(
+            self.__pid,
+            self.__signal_triggered if state.active 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
+
+class CBAppend():
+   def __init__(self, path):
+      self.__path = path
+
+   def cb(self, payload):
+      def cb(state):
+         with open(self.__path, "a") as f:
+            f.write(f"{'/' if not state.active else ''}{payload} {state.f}\n")
+      return cb
+
+class CBFork():
+   def __init__(self, triggered, released):
+      self.__triggered = triggered
+      self.__released = released
+
+   def cb(self, payload):
+      cb_triggered = self.__triggered.cb(payload)
+      cb_released = self.__released.cb(payload)
+      def cb(state):
+         if state.active:
+            return cb_triggered(state)
+         return cb_released(state)
+      return cb
+
+if __name__ == "__main__":
+   main()

poc/py-rps/test.sh

@@ -0,0 +1,31 @@
+#! /bin/bash
+
+set -e
+set -o pipefail
+
+peek() {
+   while read -r line; do
+      echo $line
+      echo $line >&2
+   done
+}
+cleanup() {
+   kill -9 $(jobs -p) || true
+}
+trap cleanup EXIT
+
+python3 ./state_to_buttons.py &
+
+python3 ./testdata/rand_0_n_stream.py \
+   -n 6 \
+   -b-min 1 \
+   -b-max 10 \
+   -d-min 100 \
+   -d-max 3000 \
+   -between 100 \
+| peek \
+| python3 ./stream_to_state.py \
+   -n 20 \
+   -m 15 \
+   -r 15 \
+   -t 15