openspuruntime 0.1.0__tar.gz

openspuruntime-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: openspuruntime
+Version: 0.1.0
+Summary: Remote Alyx I100 SPU runtime: a Flask server tunneled with Cloudflare
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Provides-Extra: host
+Requires-Dist: flask; extra == "host"
+Requires-Dist: alyxspu; extra == "host"
+Provides-Extra: waitress
+Requires-Dist: waitress; extra == "waitress"
+
+# OpenSPURuntime
+
+Use any other computer's Alyx I100 SPU as your own. The host runs a plain Flask
+server in front of the `alyxspu` driver and tunnels it with Cloudflare, so no
+port forwarding or public IP is needed.
+
+## Installation :
+
+```
+pip install "openspuruntime[host]"      # on the machine with the SPU
+pip install openspuruntime              # on the client
+```
+
+## Streaming :
+```
+openspuruntime stream --serial-port COM5 --allowed_ip all
+```
+
+## Connecting :
+```
+openspuruntime connect https://random-words.trycloudflare.com/?token=...
+```
+
+## Usage :
+#### For CLI :
+```
+openspuruntime calc "sqrt(2)*3 + sin(pi/2)"
+openspuruntime build --inputs 2 --hidden 4 --outputs 1
+openspuruntime data -c "[[[0,0],[0]],[[0,1],[1]],[[1,0],[1]],[[1,1],[0]]]"
+openspuruntime train --epochs 3000 --lr 0.5
+openspuruntime run 1 0
+```
+
+#### In python :
+```python
+from openspuruntime import Runtime
+rt = Runtime.connect("https://random-words.trycloudflare.com/?token=...")
+print(rt.calc("2+2"))
+```
+
+## Disconnecting
+```
+openspuruntime disconnect
+```
+

openspuruntime-0.1.0/README.md

@@ -0,0 +1,45 @@
+# OpenSPURuntime
+
+Use any other computer's Alyx I100 SPU as your own. The host runs a plain Flask
+server in front of the `alyxspu` driver and tunnels it with Cloudflare, so no
+port forwarding or public IP is needed.
+
+## Installation :
+
+```
+pip install "openspuruntime[host]"      # on the machine with the SPU
+pip install openspuruntime              # on the client
+```
+
+## Streaming :
+```
+openspuruntime stream --serial-port COM5 --allowed_ip all
+```
+
+## Connecting :
+```
+openspuruntime connect https://random-words.trycloudflare.com/?token=...
+```
+
+## Usage :
+#### For CLI :
+```
+openspuruntime calc "sqrt(2)*3 + sin(pi/2)"
+openspuruntime build --inputs 2 --hidden 4 --outputs 1
+openspuruntime data -c "[[[0,0],[0]],[[0,1],[1]],[[1,0],[1]],[[1,1],[0]]]"
+openspuruntime train --epochs 3000 --lr 0.5
+openspuruntime run 1 0
+```
+
+#### In python :
+```python
+from openspuruntime import Runtime
+rt = Runtime.connect("https://random-words.trycloudflare.com/?token=...")
+print(rt.calc("2+2"))
+```
+
+## Disconnecting
+```
+openspuruntime disconnect
+```
+

openspuruntime-0.1.0/openspuruntime/__init__.py

@@ -0,0 +1,13 @@
+"""OpenSPURuntime: remote Alyx I100 SPU runtime."""
+from .client import Runtime, SPUError
+
+__version__ = "0.1.0"
+__all__ = ["Runtime", "SPUError", "serve", "create_app"]
+
+
+def __getattr__(name):
+    # Lazy so a client-only install does not need Flask / alyxspu.
+    if name in ("serve", "create_app"):
+        from . import server
+        return getattr(server, name)
+    raise AttributeError(name)

openspuruntime-0.1.0/openspuruntime/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

openspuruntime-0.1.0/openspuruntime/cli.py

@@ -0,0 +1,182 @@
+"""openspuruntime command line."""
+import argparse
+import csv
+import json
+import os
+import sys
+
+from .client import Runtime, SPUError
+
+OUT_DIR = "openspu_outputs"
+
+
+def _rt():
+    return Runtime.from_session()
+
+
+def _load_samples(args):
+    if args.code:
+        text = args.code
+    elif args.file == "-":
+        text = sys.stdin.read()
+    elif args.file:
+        with open(args.file) as f:
+            text = f.read()
+    else:
+        raise SPUError("give a JSON file, '-' for stdin, or -c '<json>'")
+    return [(s[0], s[1]) for s in json.loads(text)]
+
+
+def _train(rt, epochs, lr, quiet=False):
+    step = max(1, epochs // 20)
+    last = [0]
+
+    def show(e, loss):
+        last[0] = e
+        if not quiet and (e % step == 0 or e == epochs):
+            print("epoch %d  loss %.6f" % (e, loss))
+
+    history = rt.train(epochs, lr, on_loss=show)
+    if history:
+        os.makedirs(OUT_DIR, exist_ok=True)
+        path = os.path.join(OUT_DIR, "loss.csv")
+        with open(path, "w", newline="") as f:
+            w = csv.writer(f)
+            w.writerow(["epoch", "loss"])
+            w.writerows(history)
+        try:
+            import matplotlib
+            matplotlib.use("Agg")
+            import matplotlib.pyplot as plt
+            plt.plot(*zip(*history))
+            plt.xlabel("epoch")
+            plt.ylabel("loss")
+            plt.savefig(os.path.join(OUT_DIR, "loss.png"))
+            plt.close()
+        except ImportError:
+            pass
+        print("saved loss curve to %s/" % OUT_DIR)
+    return history
+
+
+def _shell(rt):
+    print("openspuruntime shell. Type an expression to calc it. Commands: info, ping, "
+          "build I H O, train EPOCHS LR, run X..., clear, quit")
+    while True:
+        try:
+            line = input("spu> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+        if not line:
+            continue
+        cmd, *rest = line.split()
+        try:
+            if cmd in ("quit", "exit"):
+                return
+            elif cmd == "info":
+                print(rt.info())
+            elif cmd == "ping":
+                print(rt.ping())
+            elif cmd == "build":
+                rt.build(*map(int, rest)); print("ok")
+            elif cmd == "train":
+                _train(rt, int(rest[0]), float(rest[1]))
+            elif cmd == "run":
+                print(rt.run(map(float, rest)))
+            elif cmd == "clear":
+                rt.clear_data(); print("ok")
+            else:
+                print(rt.calc(line))
+        except (SPUError, ValueError, IndexError) as e:
+            print("error:", e)
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="openspuruntime",
+                                description="Remote Alyx I100 SPU runtime")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("stream", help="share the SPU plugged into this machine")
+    s.add_argument("--allowed_ip", "--allowed-ip", nargs="+", metavar="IP")
+    s.add_argument("--allow-any", action="store_true")
+    s.add_argument("--serial-port")
+    s.add_argument("--baud", type=int, default=115200)
+    s.add_argument("--no-tunnel", action="store_true")
+    s.add_argument("--install-cloudflared", action="store_true")
+    s.add_argument("--tunnel-token")
+    s.add_argument("--public-url")
+    s.add_argument("--port", type=int, default=9000)
+    s.add_argument("--host")
+    s.add_argument("--token")
+    s.add_argument("--allow-raw", action="store_true")
+    s.add_argument("--no-queue", action="store_true")
+    s.add_argument("--wsgi", choices=["werkzeug", "waitress"], default="werkzeug")
+    s.add_argument("--tls-cert")
+    s.add_argument("--tls-key")
+    s.add_argument("--public-host")
+
+    c = sub.add_parser("connect", help="connect to a host")
+    c.add_argument("url")
+    sub.add_parser("disconnect")
+    sub.add_parser("info")
+    sub.add_parser("ping")
+    sub.add_parser("shell")
+
+    k = sub.add_parser("calc"); k.add_argument("expr")
+    b = sub.add_parser("build")
+    for n in ("inputs", "hidden", "outputs"):
+        b.add_argument("--" + n, type=int, required=True)
+    d = sub.add_parser("data", help="upload a training set")
+    d.add_argument("file", nargs="?")
+    d.add_argument("-c", "--code")
+    sub.add_parser("clear")
+    t = sub.add_parser("train")
+    t.add_argument("--epochs", type=int, default=3000)
+    t.add_argument("--lr", type=float, default=0.5)
+    r = sub.add_parser("run"); r.add_argument("inputs", nargs="+", type=float)
+    return p
+
+
+def main(argv=None):
+    a = build_parser().parse_args(argv)
+    try:
+        if a.cmd == "stream":
+            from .server import serve
+            allowed = ["all"] if a.allow_any else a.allowed_ip
+            serve(serial_port=a.serial_port, allowed_ip=allowed, token=a.token, host=a.host,
+                  port=a.port, tunnel=not a.no_tunnel, tunnel_token=a.tunnel_token,
+                  public_url=a.public_url, public_host=a.public_host,
+                  install_cloudflared=a.install_cloudflared, allow_raw=a.allow_raw,
+                  wait=not a.no_queue, baud=a.baud, wsgi=a.wsgi,
+                  tls_cert=a.tls_cert, tls_key=a.tls_key)
+        elif a.cmd == "connect":
+            rt = Runtime.connect(a.url)
+            print("connected to", rt.base_url)
+            print("SPU:", rt.info())
+        elif a.cmd == "disconnect":
+            Runtime.disconnect(); print("disconnected")
+        elif a.cmd == "info":
+            print(_rt().info())
+        elif a.cmd == "ping":
+            print(_rt().ping())
+        elif a.cmd == "calc":
+            print(_rt().calc(a.expr))
+        elif a.cmd == "build":
+            _rt().build(a.inputs, a.hidden, a.outputs); print("ok")
+        elif a.cmd == "data":
+            s = _load_samples(a); _rt().set_data(s); print("uploaded %d samples" % len(s))
+        elif a.cmd == "clear":
+            _rt().clear_data(); print("ok")
+        elif a.cmd == "train":
+            _train(_rt(), a.epochs, a.lr)
+        elif a.cmd == "run":
+            print(_rt().run(a.inputs))
+        elif a.cmd == "shell":
+            _shell(_rt())
+    except SPUError as e:
+        sys.exit("error: %s" % e)
+
+
+if __name__ == "__main__":
+    main()

openspuruntime-0.1.0/openspuruntime/client.py

@@ -0,0 +1,116 @@
+"""Client for a remote OpenSPURuntime host."""
+import json
+import os
+from urllib.parse import parse_qs, urlparse
+
+import requests
+
+SESSION_FILE = os.path.join(os.path.expanduser("~"), ".openspuruntime", "session.json")
+
+
+class SPUError(Exception):
+    """Raised for device, server or connection errors."""
+
+
+def _split(url):
+    u = urlparse(url)
+    token = parse_qs(u.query).get("token", [""])[0]
+    if not u.scheme or not u.netloc:
+        raise SPUError("invalid URL: %s" % url)
+    return "%s://%s" % (u.scheme, u.netloc), token
+
+
+class Runtime:
+    def __init__(self, base_url, token, timeout=60):
+        self.base_url, self.token, self.timeout = base_url.rstrip("/"), token, timeout
+
+    # --- connection -------------------------------------------------
+    @classmethod
+    def connect(cls, url, save=True):
+        base, token = _split(url)
+        rt = cls(base, token)
+        rt.info()  # verifies URL, IP gate and token
+        if save:
+            os.makedirs(os.path.dirname(SESSION_FILE), exist_ok=True)
+            fd = os.open(SESSION_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+            with os.fdopen(fd, "w") as f:
+                json.dump({"base_url": base, "token": token}, f)
+        return rt
+
+    @classmethod
+    def from_session(cls):
+        try:
+            with open(SESSION_FILE) as f:
+                s = json.load(f)
+        except (OSError, ValueError):
+            raise SPUError("not connected. Run: openspuruntime connect <url>")
+        return cls(s["base_url"], s["token"])
+
+    @staticmethod
+    def disconnect():
+        try:
+            os.remove(SESSION_FILE)
+        except OSError:
+            pass
+
+    # --- plumbing ---------------------------------------------------
+    def _req(self, method, path, payload=None, stream=False):
+        try:
+            r = requests.request(method, self.base_url + path, json=payload, stream=stream,
+                                 headers={"Authorization": "Bearer " + self.token},
+                                 timeout=None if stream else self.timeout)
+        except requests.RequestException as e:
+            raise SPUError("connection failed: %s" % e)
+        if r.status_code >= 400:
+            try:
+                msg = r.json().get("error", r.text)
+            except ValueError:
+                msg = r.text[:200]
+            raise SPUError("%s (HTTP %d)" % (msg, r.status_code))
+        return r
+
+    def _json(self, method, path, payload=None):
+        return self._req(method, path, payload).json()
+
+    # --- SPU API (mirrors alyxspu.AlyxSPU) --------------------------
+    def ping(self):
+        return self._json("GET", "/api/ping").get("pong")
+
+    def info(self):
+        return self._json("GET", "/api/info")["info"]
+
+    def calc(self, expr):
+        return self._json("POST", "/api/calc", {"expr": expr})["result"]
+
+    def build(self, inputs, hidden, outputs):
+        self._json("POST", "/api/build", {"inputs": inputs, "hidden": hidden, "outputs": outputs})
+
+    def set_data(self, samples):
+        self._json("POST", "/api/data", {"samples": [[list(x), list(y)] for x, y in samples]})
+
+    def add_sample(self, x, y):
+        self._json("POST", "/api/data/add", {"x": list(x), "y": list(y)})
+
+    def clear_data(self):
+        self._json("POST", "/api/data/clear")
+
+    def run(self, inputs):
+        return self._json("POST", "/api/run", {"inputs": list(inputs)})["outputs"]
+
+    def command(self, line):
+        return self._json("POST", "/api/command", {"line": line})["reply"]
+
+    def train(self, epochs, lr, on_loss=None):
+        r = self._req("POST", "/api/train", {"epochs": epochs, "lr": lr}, stream=True)
+        history = []
+        for line in r.iter_lines(decode_unicode=True):
+            if not line:
+                continue
+            msg = json.loads(line)
+            if "error" in msg:
+                raise SPUError(msg["error"])
+            if "epoch" in msg:
+                history.append((msg["epoch"], msg["loss"]))
+                if on_loss:
+                    on_loss(msg["epoch"], msg["loss"])
+        return history

openspuruntime-0.1.0/openspuruntime/server.py

@@ -0,0 +1,232 @@
+"""Flask server that exposes an Alyx I100 SPU as a small JSON API."""
+import hmac
+import ipaddress
+import json
+import queue
+import secrets
+import threading
+
+from flask import Flask, Response, jsonify, request, stream_with_context
+
+
+def parse_allowed(values):
+    """Return a list of networks, or None meaning 'any IP'."""
+    nets = []
+    for v in values or []:
+        if str(v).lower() in ("all", "any", "*"):
+            return None
+        nets.append(ipaddress.ip_network(str(v), strict=False))
+    return nets
+
+
+def _ip_ok(ip_str, nets):
+    if nets is None:
+        return True
+    try:
+        ip = ipaddress.ip_address(ip_str.strip())
+    except ValueError:
+        return False
+    if getattr(ip, "ipv4_mapped", None):
+        ip = ip.ipv4_mapped
+    return any(ip in n for n in nets)
+
+
+def _err(msg, code):
+    return jsonify({"error": msg}), code
+
+
+def create_app(spu, token, allowed_ips=None, tunnel=True, allow_raw=False, wait=True):
+    """Build the Flask app.
+
+    spu         an open alyxspu.AlyxSPU
+    allowed_ips list of networks from parse_allowed(), or None for any IP
+    tunnel      True: trust CF-Connecting-IP only (cloudflared hits us from loopback)
+                False: use the socket address, loopback always allowed
+    """
+    app = Flask("openspuruntime")
+    lock = threading.Lock()
+
+    @app.before_request
+    def gate():
+        if tunnel:
+            ip = request.headers.get("CF-Connecting-IP")
+            if not ip:
+                return _err("refused: request did not come through the tunnel", 403)
+            ok = _ip_ok(ip, allowed_ips)
+        else:
+            ip = request.remote_addr or ""
+            ok = _ip_ok(ip, allowed_ips) or _ip_ok(ip, [ipaddress.ip_network("127.0.0.0/8"),
+                                                          ipaddress.ip_network("::1/128")])
+        if not ok:
+            return _err("access denied for IP %s. Ask the host to add it with "
+                        "--allowed_ip %s" % (ip, ip), 403)
+        auth = request.headers.get("Authorization", "")
+        supplied = auth[7:] if auth.lower().startswith("bearer ") else request.args.get("token", "")
+        if not hmac.compare_digest(supplied.encode(), token.encode()):
+            return _err("invalid or missing token", 401)
+
+    @app.after_request
+    def no_reuse(resp):
+        resp.headers["Connection"] = "close"  # one vetted connection is never reused
+        return resp
+
+    def body():
+        return request.get_json(silent=True) or {}
+
+    def device(fn):
+        if not lock.acquire(blocking=wait):
+            return _err("busy: the SPU is in use", 409)
+        try:
+            return jsonify(fn())
+        except (ValueError, KeyError, TypeError) as e:
+            return _err("bad request: %s" % e, 400)
+        except Exception as e:  # AlyxError, serial errors, ...
+            return _err(str(e), 502)
+        finally:
+            lock.release()
+
+    def samples_from(raw):
+        out = []
+        for s in raw:
+            x, y = s
+            out.append(([float(v) for v in x], [float(v) for v in y]))
+        if not out:
+            raise ValueError("no samples")
+        return out
+
+    @app.get("/api/ping")
+    def ping():
+        return device(lambda: {"ok": True, "pong": spu.ping()})
+
+    @app.get("/api/info")
+    def info():
+        return device(lambda: {"info": spu.info()})
+
+    @app.post("/api/calc")
+    def calc():
+        expr = body()["expr"]
+        return device(lambda: {"result": spu.calc(str(expr))})
+
+    @app.post("/api/build")
+    def build():
+        b = body()
+        i, h, o = int(b["inputs"]), int(b["hidden"]), int(b["outputs"])
+        return device(lambda: (spu.build(i, h, o), {"ok": True})[1])
+
+    @app.post("/api/data")
+    def data():
+        s = samples_from(body()["samples"])
+        return device(lambda: (spu.set_data(s), {"ok": True, "count": len(s)})[1])
+
+    @app.post("/api/data/add")
+    def data_add():
+        b = body()
+        x, y = [float(v) for v in b["x"]], [float(v) for v in b["y"]]
+        return device(lambda: (spu.add_sample(x, y), {"ok": True})[1])
+
+    @app.post("/api/data/clear")
+    def data_clear():
+        return device(lambda: (spu.clear_data(), {"ok": True})[1])
+
+    @app.post("/api/run")
+    def run():
+        x = [float(v) for v in body()["inputs"]]
+        return device(lambda: {"outputs": spu.run(x)})
+
+    @app.post("/api/command")
+    def command():
+        if not allow_raw:
+            return _err("raw commands are disabled (start the host with --allow-raw)", 403)
+        line = str(body()["line"])
+        return device(lambda: {"reply": spu.command(line)})
+
+    @app.post("/api/train")
+    def train():
+        try:
+            b = body()
+            epochs, lr = int(b["epochs"]), float(b["lr"])
+        except (KeyError, ValueError, TypeError) as e:
+            return _err("bad request: %s" % e, 400)
+        if not lock.acquire(blocking=wait):
+            return _err("busy: the SPU is in use", 409)
+
+        q = queue.Queue()
+
+        def worker():
+            try:
+                spu.train(epochs=epochs, lr=lr,
+                          on_loss=lambda e, l: q.put({"epoch": e, "loss": l}))
+                q.put({"done": True})
+            except Exception as e:
+                q.put({"error": str(e)})
+            finally:
+                lock.release()  # released by the worker, even if the client disconnects
+                q.put(None)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+        def gen():
+            while True:
+                item = q.get()
+                if item is None:
+                    return
+                yield json.dumps(item) + "\n"
+
+        return Response(stream_with_context(gen()), mimetype="application/x-ndjson")
+
+    return app
+
+
+def serve(serial_port=None, allowed_ip=None, token=None, host=None, port=9000,
+          tunnel=True, tunnel_token=None, public_url=None, public_host=None,
+          install_cloudflared=False, allow_raw=False, wait=True, baud=115200,
+          wsgi="werkzeug", tls_cert=None, tls_key=None, banner=True):
+    """Open the SPU, start the Flask server and (optionally) a Cloudflare tunnel."""
+    from alyxspu import AlyxSPU
+    from . import tunnel as tun
+
+    nets = parse_allowed(allowed_ip)
+    if tunnel and allowed_ip is None:
+        raise SystemExit("--allowed_ip is required in tunnel mode (use 'all' to allow any IP)")
+    token = token or secrets.token_urlsafe(24)
+    host = host or ("127.0.0.1" if tunnel else "0.0.0.0")
+
+    kwargs = {} if baud == 115200 else {"baud": baud}
+    try:
+        # AlyxSPU opens the port in its constructor
+        spu = AlyxSPU(serial_port, **kwargs) if serial_port else AlyxSPU(**kwargs)
+    except Exception as e:
+        raise SystemExit("could not open the SPU: %s\nPass the port with --serial-port (e.g. COM5)." % e)
+    app = create_app(spu, token, nets, tunnel=tunnel, allow_raw=allow_raw, wait=wait)
+
+    proc = None
+    try:
+        if tunnel:
+            proc, url = tun.start(port, tunnel_token, public_url, install_cloudflared)
+        else:
+            scheme = "https" if tls_cert else "http"
+            url = "%s://%s:%d" % (scheme, public_host or host, port)
+        if banner:
+            print("\nSPU connected. Run this on the client:\n")
+            print("  openspuruntime connect %s/?token=%s\n" % (url.rstrip("/"), token))
+            if allowed_ip and nets is not None:
+                print("Allowed IPs: %s" % ", ".join(str(n) for n in nets))
+            elif nets is None:
+                print("Allowing ANY IP - the token is your only protection.")
+            print("Press Ctrl+C to stop.\n")
+
+        if wsgi == "waitress":
+            from waitress import serve as wserve
+            wserve(app, host=host, port=port, threads=8)
+        else:
+            ssl_ctx = (tls_cert, tls_key) if tls_cert and tls_key else None
+            app.run(host=host, port=port, threaded=True, ssl_context=ssl_ctx)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if proc:
+            proc.terminate()
+        try:
+            spu.close()
+        except Exception:
+            pass

openspuruntime-0.1.0/openspuruntime/tunnel.py

@@ -0,0 +1,92 @@
+"""Start a Cloudflare tunnel with cloudflared."""
+import os
+import platform
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import time
+import urllib.request
+
+BIN_DIR = os.path.join(os.path.expanduser("~"), ".openspuruntime", "bin")
+BASE = "https://github.com/cloudflare/cloudflared/releases/latest/download/"
+
+
+def _asset():
+    sysname = platform.system().lower()
+    m = platform.machine().lower()
+    arch = "arm64" if m in ("arm64", "aarch64") else "arm" if m.startswith("arm") else \
+        "amd64" if m in ("x86_64", "amd64") else "386"
+    if sysname == "windows":
+        return "cloudflared-windows-%s.exe" % arch
+    if sysname == "darwin":
+        return "cloudflared-darwin-%s.tgz" % arch
+    return "cloudflared-linux-%s" % arch
+
+
+def find():
+    p = shutil.which("cloudflared")
+    if p:
+        return p
+    local = os.path.join(BIN_DIR, "cloudflared.exe" if os.name == "nt" else "cloudflared")
+    return local if os.path.exists(local) else None
+
+
+def install():
+    os.makedirs(BIN_DIR, exist_ok=True)
+    asset = _asset()
+    dest = os.path.join(BIN_DIR, "cloudflared.exe" if os.name == "nt" else "cloudflared")
+    print("Downloading cloudflared (%s)..." % asset)
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, asset)
+        urllib.request.urlretrieve(BASE + asset, path)
+        if asset.endswith(".tgz"):
+            with tarfile.open(path) as t:
+                t.extract("cloudflared", tmp)
+            path = os.path.join(tmp, "cloudflared")
+        shutil.copy(path, dest)
+    os.chmod(dest, os.stat(dest).st_mode | stat.S_IEXEC)
+    return dest
+
+
+def start(port, tunnel_token=None, public_url=None, auto_install=False):
+    """Return (process, public_url)."""
+    exe = find()
+    if not exe:
+        ok = auto_install
+        if not ok and sys.stdin.isatty():
+            ok = input("cloudflared not found. Download the official binary? [y/N] ").lower().startswith("y")
+        if not ok:
+            raise SystemExit("cloudflared is required. Install it or pass --install-cloudflared.")
+        exe = install()
+
+    if tunnel_token:
+        if not public_url:
+            raise SystemExit("--public-url is required with --tunnel-token")
+        proc = subprocess.Popen([exe, "tunnel", "--no-autoupdate", "run", "--token", tunnel_token],
+                                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return proc, public_url
+
+    proc = subprocess.Popen([exe, "tunnel", "--no-autoupdate", "--url", "http://127.0.0.1:%d" % port],
+                            stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
+    found = {}
+
+    def reader():
+        for line in proc.stderr:
+            m = re.search(r"https://[a-z0-9-]+\.trycloudflare\.com", line)
+            if m and "url" not in found:
+                found["url"] = m.group(0)
+
+    threading.Thread(target=reader, daemon=True).start()
+    for _ in range(300):
+        if "url" in found:
+            return proc, found["url"]
+        if proc.poll() is not None:
+            break
+        time.sleep(0.1)
+    proc.terminate()
+    raise SystemExit("could not start the Cloudflare quick tunnel")

openspuruntime-0.1.0/openspuruntime.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: openspuruntime
+Version: 0.1.0
+Summary: Remote Alyx I100 SPU runtime: a Flask server tunneled with Cloudflare
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Provides-Extra: host
+Requires-Dist: flask; extra == "host"
+Requires-Dist: alyxspu; extra == "host"
+Provides-Extra: waitress
+Requires-Dist: waitress; extra == "waitress"
+
+# OpenSPURuntime
+
+Use any other computer's Alyx I100 SPU as your own. The host runs a plain Flask
+server in front of the `alyxspu` driver and tunnels it with Cloudflare, so no
+port forwarding or public IP is needed.
+
+## Installation :
+
+```
+pip install "openspuruntime[host]"      # on the machine with the SPU
+pip install openspuruntime              # on the client
+```
+
+## Streaming :
+```
+openspuruntime stream --serial-port COM5 --allowed_ip all
+```
+
+## Connecting :
+```
+openspuruntime connect https://random-words.trycloudflare.com/?token=...
+```
+
+## Usage :
+#### For CLI :
+```
+openspuruntime calc "sqrt(2)*3 + sin(pi/2)"
+openspuruntime build --inputs 2 --hidden 4 --outputs 1
+openspuruntime data -c "[[[0,0],[0]],[[0,1],[1]],[[1,0],[1]],[[1,1],[0]]]"
+openspuruntime train --epochs 3000 --lr 0.5
+openspuruntime run 1 0
+```
+
+#### In python :
+```python
+from openspuruntime import Runtime
+rt = Runtime.connect("https://random-words.trycloudflare.com/?token=...")
+print(rt.calc("2+2"))
+```
+
+## Disconnecting
+```
+openspuruntime disconnect
+```
+

openspuruntime-0.1.0/openspuruntime.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+openspuruntime/__init__.py
+openspuruntime/__main__.py
+openspuruntime/cli.py
+openspuruntime/client.py
+openspuruntime/server.py
+openspuruntime/tunnel.py
+openspuruntime.egg-info/PKG-INFO
+openspuruntime.egg-info/SOURCES.txt
+openspuruntime.egg-info/dependency_links.txt
+openspuruntime.egg-info/entry_points.txt
+openspuruntime.egg-info/requires.txt
+openspuruntime.egg-info/top_level.txt

openspuruntime-0.1.0/openspuruntime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openspuruntime-0.1.0/openspuruntime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openspuruntime = openspuruntime.cli:main

openspuruntime-0.1.0/openspuruntime.egg-info/requires.txt

@@ -0,0 +1,8 @@
+requests
+
+[host]
+flask
+alyxspu
+
+[waitress]
+waitress

openspuruntime-0.1.0/openspuruntime.egg-info/top_level.txt

@@ -0,0 +1 @@
+openspuruntime

openspuruntime-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openspuruntime"
+version = "0.1.0"
+description = "Remote Alyx I100 SPU runtime: a Flask server tunneled with Cloudflare"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = ["requests"]
+
+[project.optional-dependencies]
+host = ["flask", "alyxspu"]
+waitress = ["waitress"]
+
+[project.scripts]
+openspuruntime = "openspuruntime.cli:main"
+
+[tool.setuptools]
+packages = ["openspuruntime"]

openspuruntime-0.1.0/setup.cfg

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