HaltingMachine 0.1__tar.gz

haltingmachine-0.1/HaltingMachine.egg-info/PKG-INFO

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

haltingmachine-0.1/HaltingMachine.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+HaltingMachine.py
+README.md
+pyproject.toml
+HaltingMachine.egg-info/PKG-INFO
+HaltingMachine.egg-info/SOURCES.txt
+HaltingMachine.egg-info/dependency_links.txt
+HaltingMachine.egg-info/entry_points.txt
+HaltingMachine.egg-info/requires.txt
+HaltingMachine.egg-info/top_level.txt
+machine/__init__.py
+machine/field.py
+machine/inverter.py
+machine/observer.py

haltingmachine-0.1/HaltingMachine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

haltingmachine-0.1/HaltingMachine.egg-info/entry_points.txt

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

haltingmachine-0.1/HaltingMachine.egg-info/requires.txt

@@ -0,0 +1 @@
+wcwidth>=0.2

haltingmachine-0.1/HaltingMachine.egg-info/top_level.txt

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

haltingmachine-0.1/HaltingMachine.py

@@ -0,0 +1,4 @@
+from machine.field import main
+
+if __name__ == "__main__":
+    main()

haltingmachine-0.1/PKG-INFO

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

haltingmachine-0.1/README.md

@@ -0,0 +1,32 @@
+# HaltingMachine
+
+A tiny loopback-socket specimen of an Oblivious Compute field.
+
+Install from this directory:
+
+```bash
+pipx install --force .
+HaltingMachine
+```
+
+Choose the number of observers and the number of inverters. The launcher assigns the last *N* observers as inverters, randomly chooses which observer inherits the invoking shell, and drops every observer into Genesis. The random choice affects terminal persistence only; it does not change identity, role, or field behavior.
+
+## Runtime
+
+- `↑` / `↓` selects `HALT` or `REPEAT`.
+- `SPACE` exits that observer.
+- Every observer begins on `HALT` and `🪨`.
+- A healthy observer advances `🪨 → 📜 → ✂️ → 🪨`.
+- An inverted observer advances `🪨 → ✂️ → 📜 → 🪨`.
+- Healthy `REPEAT` originates its forward successor once per second; healthy `HALT` originates nothing.
+- Inverted `HALT` originates its reverse successor once per second; inverted `REPEAT` originates nothing.
+- A projection never mutates its sender. A state changes only after receiving the one successor admitted by that observer's transition rule.
+- Every accepted state is semantically reprojected once into the oblivious medium.
+- Acceptance starts a one-second refractory interval. R/P/S packets arriving during that interval are discarded, so each observer can mutate at most once per second.
+- Active origination is phase-reset by the same acceptance. The field therefore appears clocked at 1 Hz without a shared master clock.
+
+There is no DDUP/history window in this specimen. The present R/P/S state itself makes duplicates inadmissible: after accepting a ticket, that same ticket is no longer the observer's successor.
+
+The red-handle scissors wire state is the real UTF-8 `✂️` emoji. Its display row inserts one terminal cell after each glyph because some Linux terminal/font combinations draw the emoji across two cells while advancing the cursor by one.
+
+On exit, HaltingMachine restores the terminal, clears the screen, and returns the original window to a clean shell. Ctrl-C exits cleanly; Ctrl-Z and Ctrl-\ are ignored while the machine owns the terminal.

haltingmachine-0.1/machine/__init__.py

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

haltingmachine-0.1/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, 5)
+        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()

haltingmachine-0.1/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()

haltingmachine-0.1/machine/observer.py

@@ -0,0 +1,102 @@
+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):
+    paint(); print("\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"
+    print(center(halt), center(repeat), "", center(ART[state], 8), "", 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):
+    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
+    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 = emit_at = 0.0; shown_seen = -1
+    try:
+        while True:
+            now = time.monotonic()
+            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 now >= ready_at:
+                    # ================= LINCHPIN ================= #
+                    admissible = msg == step[state]
+                    # ============================================ #
+                    if admissible:
+                        state = msg; ready_at = emit_at = now + 1.0
+                        send(sock, total, msg, index)
+                        draw(identity, mode, state, invert_controls)
+            if len(seen) < total:
+                if len(seen) != shown_seen:
+                    draw(identity, mode, state, invert_controls, f"{len(seen)} / {total}"); shown_seen = len(seen)
+                time.sleep(.05); continue
+            if ready_at == 0.0:
+                draw(identity, mode, state, invert_controls); ready_at = emit_at = now + 1.0
+            active = (1 - mode) if invert_mode else mode
+            if 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"):
+                    down = key == b"\x1b[B"
+                    mode = 1 if (not down if invert_controls else down) else 0
+                    emit_at = time.monotonic() + 1.0
+                    draw(identity, mode, state, invert_controls)
+    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()

haltingmachine-0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "HaltingMachine"
+version = "0.1"
+description = "A tiny Oblivious Compute halting-machine specimen"
+requires-python = ">=3.10"
+dependencies = ["wcwidth>=0.2"]
+
+[project.scripts]
+HaltingMachine = "HaltingMachine:main"
+
+[tool.setuptools]
+py-modules = ["HaltingMachine"]
+packages = ["machine"]

haltingmachine-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+