9Volt 0.0.1__py3-none-any.whl

9volt-0.0.1.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: 9Volt
+Version: 0.0.1
+Summary: A tiny Oblivious Compute halting-machine specimen
+Requires-Python: >=3.10
+Requires-Dist: wcwidth>=0.2

9volt-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+HaltingMachine.py,sha256=uFP7vjkHDTU7iowZ8J6zi_swSH3CDSGJWLOQDkR71Xo,292
+Machine/Spacewalk.py,sha256=L-n4-_9j7_BkiqEbc9pPpOPlKK5OesJ7g0X6eJ2UQQI,1847
+Machine/__init__.py,sha256=gWfketXvBDaqOxZrk4DnoRPuCXCrdQO3NTkB8Y-netc,53
+Machine/field.py,sha256=x0HVUWjfyvgSJ4p0K7yfJPmH6Ait_aIQv0a4ZBku1yc,2988
+Machine/inverter.py,sha256=SUyPNGN-q-OnWRucvTqp74yIVvDOWmUTDndds6roJXU,277
+Machine/observer.py,sha256=WsZ1oUMyXItKBPbl34Uj4WfbW7rQod-AiM2dSRluXUA,6286
+9volt-0.0.1.dist-info/METADATA,sha256=mU-vVUk-OMguM7LHTu5hCg6tALbY_skSkOy3e4ddZcI,160
+9volt-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+9volt-0.0.1.dist-info/entry_points.txt,sha256=xFGFsuNord-JFO1IXqag_U7lVtBmc_xyg5UA3hJzrlY,55
+9volt-0.0.1.dist-info/top_level.txt,sha256=KqgqQ1tFPdtcFboqn1xrkVgv7iRX2pjJP8iCFkN1NZM,23
+9volt-0.0.1.dist-info/RECORD,,

9volt-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

9volt-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+HaltingMachine = HaltingMachine:main

9volt-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+HaltingMachine
+Machine

HaltingMachine.py

@@ -0,0 +1,7 @@
+import os, sys
+from Machine.field import main
+if __name__ == "__main__":
+    if sys.argv[1:] not in ([], ["Spacewalk.py"], ["Spacewalk"]):
+        raise SystemExit("Usage: python HaltingMachine.py [Spacewalk.py]")
+    os.environ["HALTING_SPACEWALK"] = "1" if sys.argv[1:] else "0"
+    main()

Machine/Spacewalk.py

@@ -0,0 +1,50 @@
+# Change only this value to adjust Spacewalk's proposal and doorway pace.
+INTERVAL = 3.0
+
+POSITIVE = ('000', '100', '110', '111')
+NEGATIVE = ('000', '001', '011', '111')
+LATERAL = frozenset(('010', '101'))
+
+
+class Spacewalk:
+    def __init__(self, inverted=False):
+        self.inverted = inverted
+        self.state = self.previous = '000'
+        self.doorway_at = None
+
+    @property
+    def lane(self):
+        return NEGATIVE if self.inverted else POSITIVE
+
+    @property
+    def shell(self):
+        return self.state.count('1')
+
+    def propose(self):
+        position = self.lane.index(self.state)
+        return self.lane[position + 1] if position < 3 else None
+
+    def accept(self, incoming, now=0):
+        successor = self.propose()
+        # ================= LINCHPIN ================= #
+        if incoming != successor or successor is None:
+            return None
+        # ============================================ #
+        assert sum(a != b for a, b in zip(self.state, successor)) == 1
+        self.previous, self.state = self.state, successor
+        if successor == '111': self.doorway_at = now + INTERVAL
+        return successor
+
+    def doorway(self):
+        assert self.state == '111'
+        self.previous = self.state
+        self.inverted = not self.inverted
+        self.state, self.doorway_at = '000', None
+        return self.state
+
+    def display(self):
+        emblems = ('🪨', '✂️', '📜', '🪨') if self.inverted else ('🪨', '📜', '✂️', '🪨')
+        icons = ''.join(glyph + (' ' if glyph == '✂️' else '') for glyph in emblems)
+        pointer = ' ' * (4 + 2 * self.shell)
+        left, right = (self.state, self.previous) if self.state == '000' and self.previous == '111' else (self.previous, self.state)
+        return pointer + '🔻', f'{left} {icons} {right}', pointer + '🔺'

Machine/__init__.py

@@ -0,0 +1 @@
+"""HaltingMachine: observer, inverter, and field."""

Machine/field.py

@@ -0,0 +1,75 @@
+import os, platform, random, shlex, shutil, signal, subprocess, sys, termios, tty
+from wcwidth import wcswidth
+
+
+def paint():
+    sys.stdout.write("\033[40m\033[97m\033[2J\033[H\033[?25l")
+
+
+def clear():
+    sys.stdout.write("\033[?25h\033[0m\033[2J\033[H"); sys.stdout.flush()
+
+
+def center(text):
+    return " " * max(0, (os.get_terminal_size().columns - wcswidth(text)) // 2) + text
+
+
+def choose(label, lo, hi, value):
+    old = termios.tcgetattr(sys.stdin); tty.setcbreak(sys.stdin.fileno())
+    try:
+        while True:
+            paint(); print("\n\n" + center("HaltingMachine"), "\n", center(label), "", center(str(value)), sep="\n", flush=True)
+            key = os.read(sys.stdin.fileno(), 3)
+            if key in (b"\r", b"\n"): return value
+            if key == b"\x1b[A": value = min(hi, value + 1)
+            elif key == b"\x1b[B": value = max(lo, value - 1)
+    finally: termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old)
+
+
+def terminal_command(cmd):
+    names = ("kitty", "konsole", "gnome-terminal", "xfce4-terminal", "alacritty")
+    terminal = next((shutil.which(x) for x in names if shutil.which(x)), None)
+    terminal = terminal or shutil.which(os.environ.get("TERMINAL", ""))
+    terminal = terminal or shutil.which("x-terminal-emulator") or shutil.which("xterm")
+    if not terminal: raise SystemExit("No terminal emulator found")
+    name = os.path.basename(os.path.realpath(terminal))
+    if name == "gnome-terminal": return [terminal, "--", *cmd]
+    if name == "xfce4-terminal": return [terminal, "--command", shlex.join(cmd)]
+    if name == "alacritty": return [terminal, "-T", "HaltingMachine", "-e", *cmd]
+    if name == "kitty": return [terminal, "--title", "HaltingMachine", *cmd]
+    return [terminal, "-e", *cmd]
+
+
+def spawn(module, index, total):
+    cmd = [sys.executable, "-m", module, str(index), str(total)]
+    env = os.environ.copy(); env["PYTHONIOENCODING"] = "utf-8"
+    if platform.system() == "Darwin":
+        line = shlex.join(cmd).replace('"', '\\"')
+        subprocess.Popen(["osascript", "-e", f'tell application "Terminal" to do script "{line}"'])
+    else: subprocess.Popen(terminal_command(cmd), env=env)
+
+
+def main():
+    old_handlers = {s: signal.getsignal(s) for s in (signal.SIGTSTP, signal.SIGQUIT)}
+    for s in old_handlers: signal.signal(s, signal.SIG_IGN)
+    try:
+        total = choose("OBSERVERS", 1, 10, 3)
+        inverted = choose("INVERTERS", 0, total, min(1, total))
+        first = total - inverted
+        index = random.randrange(total)
+        for i in range(total):
+            if i != index:
+                spawn("Machine.inverter" if i >= first else "Machine.observer", i, total)
+        if index >= first:
+            from .inverter import run
+        else:
+            from .observer import run
+        run(index, total)
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        for s, h in old_handlers.items(): signal.signal(s, h)
+        clear()
+
+
+if __name__ == "__main__": main()

Machine/inverter.py

@@ -0,0 +1,14 @@
+import sys
+from .observer import REVERSE, run as observe
+
+
+def run(index, total):
+    observe(index, total, step=REVERSE, invert_controls=True, invert_mode=True)
+
+
+def main():
+    index, total = map(int, sys.argv[1:3])
+    run(index, total)
+
+
+if __name__ == "__main__": main()

Machine/observer.py

@@ -0,0 +1,134 @@
+import os, select, signal, socket, sys, termios, time, tty
+from wcwidth import wcswidth
+
+ROCK, PAPER, SCISSORS = "🪨", "📜", "✂️"
+FORWARD = {ROCK: PAPER, PAPER: SCISSORS, SCISSORS: ROCK}
+REVERSE = {v: k for k, v in FORWARD.items()}
+ART = {ROCK: ROCK * 4, PAPER: PAPER * 4, SCISSORS: "✂️ " * 4}
+GREEK = ("Γ", "Δ", "Ε", "Θ", "Λ", "Π", "Σ", "Φ", "Ψ", "Ω")
+BASE = 43120
+
+def paint():
+    sys.stdout.write("\033[40m\033[97m\033[2J\033[H\033[?25l")
+
+def clear():
+    sys.stdout.write("\033[?25h\033[0m\033[2J\033[H"); sys.stdout.flush()
+
+def center(text, width=None):
+    width = wcswidth(text) if width is None else width
+    return " " * max(0, (os.get_terminal_size().columns - width) // 2) + text
+
+def draw(identity, mode, state, inverted=False, genesis=None, cube=None):
+    paint(); print("\n\n\n\n" + center(f"{identity} HaltingMachine {identity}"), "\n")
+    if genesis is not None:
+        print(center("GENESIS"), "\n", center(genesis), flush=True); return
+    face = "🙃" if inverted else "🙂"
+    halt = f"{face}HALT{face}" if mode == 0 else "HALT"
+    repeat = f"{face}REPEAT{face}" if mode else "REPEAT"
+    visuals = cube.display() if cube else (ART[state],)
+    positions = [center(text, 16 if cube else 8) for text in visuals]
+    if cube:
+        print(center(halt), center(repeat), *positions, ' ' + center("SPACE TO EXIT"), sep="\n", flush=True)
+    else:
+        print(center(halt), center(repeat), '', *positions, '', ' ' + center("SPACE TO EXIT"), sep="\n", flush=True)
+
+def send(sock, total, payload, skip):
+    data = payload.encode("utf-8")
+    for i in range(total):
+        if i != skip:
+            try: sock.sendto(data, ("127.0.0.1", BASE + i))
+            except OSError: pass
+
+def run(index, total, step=FORWARD, invert_controls=False, invert_mode=False):
+    cube = None
+    if os.environ.get("HALTING_SPACEWALK") == "1":
+        from .Spacewalk import Spacewalk, INTERVAL
+        cube = Spacewalk(invert_mode)
+    interval = INTERVAL if cube else 1.0
+    identity = GREEK[index]
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setblocking(False); sock.bind(("127.0.0.1", BASE + index))
+    seen, state, mode = {index}, ROCK, 0
+    def show(genesis=None):
+        draw(identity, mode, state, cube.inverted if cube else invert_controls, genesis, cube)
+    old = termios.tcgetattr(sys.stdin); tty.setcbreak(sys.stdin.fileno())
+    ignored = (signal.SIGTSTP, signal.SIGQUIT)
+    handlers = {s: signal.getsignal(s) for s in ignored}
+    for s in ignored: signal.signal(s, signal.SIG_IGN)
+    hello_at = ready_at = 0.0; emit_at = None if cube else 0.0; shown_seen = -1
+    try:
+        while True:
+            now = time.monotonic()
+            if cube and cube.doorway_at is not None and now >= cube.doorway_at:
+                cube.doorway()
+                mode = int(cube.inverted)
+                emit_at = None  # Doorway resets to an effectively HALTed relay.
+                show()
+            if now >= hello_at:
+                send(sock, total, f"H{index}", index); hello_at = now + .25
+            while True:
+                try: msg = sock.recvfrom(64)[0].decode("utf-8")
+                except BlockingIOError: break
+                if msg.startswith("H"):
+                    seen.add(int(msg[1:]))
+                elif cube or now >= ready_at:
+                    if cube:
+                        admitted = cube.accept(msg, now)
+                        active = (1 - mode) if cube.inverted else mode
+                        if admitted is not None and active:
+                            emit_at = now + interval  # Admission rephases the repeater.
+                        elif (admitted is None and active and emit_at is None
+                              and len(msg) == 3 and set(msg) <= {'0', '1'}):
+                            emit_at = now + interval  # One delayed reply to a rejected Trinity.
+                    else:
+                        # ================= LINCHPIN ================= #
+                        admissible = msg == step[state]
+                        # ============================================ #
+                        admitted = msg if admissible else None
+                    if admitted is not None:
+                        if not cube:
+                            state = admitted
+                            ready_at = emit_at = now + 1.0
+                        send(sock, total, admitted, index)
+                        show()
+            if len(seen) < total:
+                if len(seen) != shown_seen:
+                    show(f"{len(seen)} / {total}"); shown_seen = len(seen)
+                time.sleep(.05); continue
+            if ready_at == 0.0:
+                show(); ready_at = now + interval
+                if not cube: emit_at = ready_at
+                elif cube and cube.inverted: emit_at = emit_at or ready_at
+            active = (1 - mode) if (cube.inverted if cube else invert_mode) else mode
+            if cube:
+                if active and emit_at is not None and now >= emit_at:
+                    proposal = cube.propose()
+                    if proposal is not None: send(sock, total, proposal, index)
+                    emit_at = None  # One proposal per encounter; listen for another.
+            elif active and now >= ready_at and now >= emit_at:
+                send(sock, total, step[state], index)
+                emit_at = now + 1.0
+            ready, _, _ = select.select([sys.stdin], [], [], .05)
+            if ready:
+                key = os.read(sys.stdin.fileno(), 3)
+                if key == b" ": break
+                if key in (b"\x1b[A", b"\x1b[B"):
+                    mode = 1 - mode
+                    if cube:
+                        active = (1 - mode) if cube.inverted else mode
+                        emit_at = time.monotonic() + interval if active else None
+                    else:
+                        emit_at = time.monotonic() + 1.0
+                    show()
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        for s, h in handlers.items(): signal.signal(s, h)
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old)
+        clear(); sock.close()
+
+def main():
+    index, total = map(int, sys.argv[1:3])
+    run(index, total)
+
+if __name__ == "__main__": main()