elastik 0.0.1__py3-none-win_amd64.whl

elastik/__init__.py

@@ -0,0 +1,151 @@
+"""elastik — pastebin with HMAC that accidentally became a web OS.
+
+Quickstart (NumPy-style — module-level calls, no instantiation):
+
+    import elastik
+
+    e = elastik.start(token="x")          # spawns the bundled rust core
+    e.put("/home/note", "hello")          # PUT
+    print(e.get("/home/note", raw=True))  # bytes back
+    elastik.stop()                        # kills the child
+
+Or skip the explicit start() and point at an already-running elastik
+(env: `ELASTIK_URL=http://elastik.local:3005 ELASTIK_TOKEN=xxx`):
+
+    import elastik
+    elastik.put("/home/note", "hello")
+    print(elastik.get("/home/note", raw=True))
+
+Reactor (declarative event handlers — see Elastik-core/README.md §L2):
+
+    @elastik.listen("/home/inbox/*")
+    def triage(body, world, meta):
+        if b"urgent" in body:
+            return elastik.Reply(f"/home/alerts/{world.split('/')[-1]}", body)
+        return elastik.Archive()
+
+    elastik.serve(port=3200)              # runs as fanout sidecar
+
+Bundled binary lives at `elastik/_bin/elastik-core[.exe]` and is invoked
+as a child process. No FFI, no compile-on-install. Same shape as
+NumPy shipping precompiled C kernels.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from elastik.sdk import Elastik, ElastikError
+from elastik.reactor import (
+    listen,
+    MoveTo,
+    Reply,
+    Archive,
+    Drop,
+    Action,
+    Ctx,
+    finalize,
+    serve,
+)
+from elastik._spawn import (
+    start,
+    stop,
+    is_running,
+    default_url,
+    binary_info,
+)
+
+__all__ = [
+    # Class — for users who want explicit instances
+    "Elastik",
+    "ElastikError",
+    # Reactor sugar
+    "listen", "MoveTo", "Reply", "Archive", "Drop", "Action", "Ctx",
+    "finalize", "serve",
+    # Lifecycle
+    "start", "stop", "is_running", "default_url", "binary_info",
+    # Module-level convenience (NumPy-shaped)
+    "put", "get", "head", "delete", "list_worlds", "shaped",
+]
+
+__version__ = "0.0.1"
+
+
+# ── module-level singleton client ──────────────────────────────────
+# Lazy: only built on first call. Lets `import elastik` succeed even if
+# no server is running (you only need a server when you actually call).
+
+_default_client: Elastik | None = None
+
+
+def _client() -> Elastik:
+    """Get-or-build the default singleton client.
+
+    Pinned to ELASTIK_URL (default http://127.0.0.1:3005, the Python
+    reference impl port). Token from ELASTIK_TOKEN.
+
+    If you spawned a child via `elastik.start(port=N, token=T)`, that
+    call returns its own client and ALSO updates this singleton so
+    module-level `elastik.put(...)` lands at your child.
+    """
+    global _default_client
+    if _default_client is None:
+        _default_client = Elastik(
+            default_url(),
+            token=os.getenv("ELASTIK_TOKEN", ""),
+        )
+    return _default_client
+
+
+def _set_default(client: Elastik) -> None:
+    """Internal: rebind the singleton (called from start()).
+    Public API is just: call start(), use module-level functions."""
+    global _default_client
+    _default_client = client
+
+
+# Re-export start() to also bind the singleton, so the next 模式 works:
+#   e = elastik.start()      # works (returns client)
+#   elastik.put("/x", "y")   # also works (uses the same client)
+_orig_start = start
+
+
+def start(*args: Any, **kwargs: Any):  # type: ignore[no-redef]
+    client = _orig_start(*args, **kwargs)
+    _set_default(client)
+    return client
+
+
+# ── module-level CRUD ──────────────────────────────────────────────
+# These are the "np.array([...])" of elastik. Brutal. One import,
+# call.
+
+def put(path: str, data, **meta: Any) -> dict:
+    """elastik.put('/home/note', 'hello', actor='me') -> {'ok': True, ...}"""
+    return _client().put(path, data, **meta)
+
+
+def get(path: str, raw: bool = False) -> Any:
+    """elastik.get('/home/note', raw=True) -> bytes
+       elastik.get('/home/note')           -> dict envelope"""
+    return _client().get(path, raw=raw)
+
+
+def head(path: str) -> dict[str, str]:
+    """elastik.head('/home/note') -> {'x-meta-...': '...'}"""
+    return _client().head(path)
+
+
+def delete(path: str) -> bool:
+    """elastik.delete('/home/note') -> True/False"""
+    return _client().delete(path)
+
+
+def list_worlds() -> list[str]:
+    """elastik.list_worlds() -> ['inbox/x', 'archive/y', ...]"""
+    return _client().list()
+
+
+def shaped(path: str, accept: str = "text/html", intent: str = "") -> bytes:
+    """elastik.shaped('/home/x', accept='text/html', intent='render as card')"""
+    return _client().shaped(path, accept=accept, intent=intent)

elastik/__main__.py

@@ -0,0 +1,67 @@
+"""`python -m elastik` — quick info + REPL helpers.
+
+  python -m elastik                  # show binary info
+  python -m elastik run               # spawn the bundled core, block
+  python -m elastik run --port 3105  # custom port + env
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from elastik._spawn import binary_info, start, stop
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="elastik")
+    sub = parser.add_subparsers(dest="cmd")
+
+    sub.add_parser("info", help="show bundled-binary info")
+
+    p_run = sub.add_parser("run", help="launch bundled elastik-core (foreground)")
+    p_run.add_argument("--host", default="127.0.0.1")
+    p_run.add_argument("--port", type=int, default=3105)
+    p_run.add_argument("--key", default="elastik-default-key")
+    p_run.add_argument("--token", default="")
+    p_run.add_argument("--approve-token", dest="approve_token", default="")
+    p_run.add_argument("--data-dir", dest="data_dir", default=None)
+    p_run.add_argument("--listeners", default="")
+
+    args = parser.parse_args()
+
+    if args.cmd in (None, "info"):
+        info = binary_info()
+        for k, v in info.items():
+            print(f"  {k}: {v}")
+        return 0
+
+    if args.cmd == "run":
+        try:
+            client = start(
+                host=args.host,
+                port=args.port,
+                key=args.key,
+                token=args.token,
+                approve_token=args.approve_token,
+                data_dir=args.data_dir,
+                listeners=args.listeners,
+                quiet=False,
+            )
+            print(f"elastik running at {client.url}", flush=True)
+            print("  Ctrl-C to stop", flush=True)
+            try:
+                while True:
+                    import time
+                    time.sleep(3600)
+            except KeyboardInterrupt:
+                pass
+        finally:
+            stop()
+        return 0
+
+    parser.print_help()
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

elastik/_spawn.py

@@ -0,0 +1,151 @@
+"""Spawn the bundled elastik-core Rust binary as a child process.
+
+This is the "NumPy ships C kernels in the wheel" trick. The Rust
+binary lives at `elastik/_bin/elastik-core[.exe]`, was built once on a
+build machine, and is shipped as `package_data`. `elastik.start()`
+launches it in a subprocess and returns a pre-bound `Elastik` client.
+
+The user does:
+
+    import elastik
+    e = elastik.start(token="x")
+    e.put("/home/note", "hi")
+    print(e.get("/home/note", raw=True))
+    elastik.stop()
+
+…and never sees a Cargo.toml.
+"""
+from __future__ import annotations
+
+import atexit
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+
+_proc: Optional[subprocess.Popen] = None
+
+
+def _binary_path() -> Path:
+    """Locate the bundled binary inside the installed package."""
+    here = Path(__file__).resolve().parent / "_bin"
+    name = "elastik-core.exe" if sys.platform == "win32" else "elastik-core"
+    return here / name
+
+
+def _wait_for_port(host: str, port: int, deadline_s: float = 10.0) -> bool:
+    """Poll until the server accepts a TCP connection or we give up."""
+    end = time.time() + deadline_s
+    while time.time() < end:
+        try:
+            with socket.create_connection((host, port), timeout=0.3):
+                return True
+        except OSError:
+            time.sleep(0.05)
+    return False
+
+
+def start(
+    port: int = 3105,
+    host: str = "127.0.0.1",
+    key: str = "elastik-default-key",
+    token: str = "",
+    approve_token: str = "",
+    data_dir: Optional[str] = None,
+    listeners: str = "",
+    quiet: bool = True,
+):
+    """Launch the bundled elastik-core. Returns a pre-bound Elastik client.
+
+    All process state is the user's: token, port, key, data dir. We only
+    set sane defaults so `elastik.start()` with no arguments produces a
+    working instance pinned to localhost.
+    """
+    global _proc
+    binary = _binary_path()
+    if not binary.exists():
+        raise RuntimeError(
+            f"bundled binary not found: {binary}\n"
+            "If you're working from source, build it first:\n"
+            "  cd Elastik-core && cargo build --release\n"
+            "  cp target/release/elastik-core* "
+            f"{binary.parent}/"
+        )
+
+    if _proc is not None and _proc.poll() is None:
+        raise RuntimeError(
+            "elastik already running in this process — call elastik.stop() first"
+        )
+
+    env = os.environ.copy()
+    env["ELASTIK_HOST"] = host
+    env["ELASTIK_PORT"] = str(port)
+    env["ELASTIK_KEY"] = key
+    if token:
+        env["ELASTIK_TOKEN"] = token
+    if approve_token:
+        env["ELASTIK_APPROVE_TOKEN"] = approve_token
+    if data_dir:
+        env["ELASTIK_DATA"] = str(data_dir)
+    if listeners:
+        env["ELASTIK_LISTENERS"] = listeners
+
+    out = subprocess.DEVNULL if quiet else None
+    _proc = subprocess.Popen([str(binary)], env=env, stdout=out, stderr=out)
+    atexit.register(stop)
+
+    if not _wait_for_port(host, port):
+        stop()
+        raise RuntimeError(
+            f"elastik-core failed to start on {host}:{port} within 10s"
+        )
+
+    # Re-import here to dodge a circular import at module load
+    from elastik.sdk import Elastik
+
+    return Elastik(f"http://{host}:{port}", token=token)
+
+
+def stop() -> None:
+    """Kill the launched binary, if any. Safe to call multiple times."""
+    global _proc
+    if _proc is None:
+        return
+    try:
+        _proc.terminate()
+        try:
+            _proc.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            _proc.kill()
+            _proc.wait(timeout=2)
+    except OSError:
+        pass
+    _proc = None
+
+
+def is_running() -> bool:
+    return _proc is not None and _proc.poll() is None
+
+
+def default_url() -> str:
+    """Where the module-level `elastik.put`/`elastik.get` calls land by
+    default. Override with `ELASTIK_URL`. Falls back to the local
+    server.py port (3005) so this module also works against the existing
+    Python reference impl."""
+    return os.getenv("ELASTIK_URL", "http://127.0.0.1:3005")
+
+
+def binary_info() -> dict:
+    """Where is the bundled binary? How big? Does it exist? — useful
+    for `python -m elastik` debugging."""
+    p = _binary_path()
+    return {
+        "path": str(p),
+        "exists": p.exists(),
+        "size_bytes": p.stat().st_size if p.exists() else None,
+        "platform": sys.platform,
+    }

elastik/reactor.py

@@ -0,0 +1,275 @@
+"""L2 — declarative reactor sugar over L1 atoms.
+
+The reactor is the "千人千面 in one event loop" pattern, made writable.
+Two deployment shapes; same `@listen` syntax for both:
+
+  1. **Plugin** (in-process with elastik-python).
+     Write a plugin file, end with `ROUTES, handle = finalize()`.
+     elastik-python's plugin runtime hot-loads it.
+
+  2. **Sidecar** (separate process; elastik-core fans out via HTTP).
+     Run `python my_agent.py` which calls `serve(host, port)`.
+     Configure elastik-core with
+     `ELASTIK_LISTENERS="/home/inbox/*=http://my-agent:port"`.
+
+Both shapes match the manifesto: code lives in one place; the runtime
+decides how to invoke it. The handler is pure — input -> Action.
+
+Action classes describe intent. Execution happens in the reactor (not
+in the handler). This is the Harvard split inside the reactor itself:
+handler = judgment, executor = side effects.
+
+stdlib + sdk.elastik. ~200 lines.
+"""
+from __future__ import annotations
+
+import http.server
+import inspect
+import json
+import threading
+from typing import Any, Callable
+
+from elastik.sdk import Elastik
+
+
+# ── registration ────────────────────────────────────────────────────
+
+_routes: dict[str, Callable[..., Any]] = {}
+
+
+def listen(pattern: str):
+    """Register a handler for a path pattern.
+
+    Pattern is prefix-with-trailing-`*`:
+      "/home/inbox/*"  matches "/home/inbox/alice/abc"
+      "/home/foo"      matches exactly "/home/foo"
+      "*"              matches everything
+
+    The handler signature is introspected. It receives `body` (bytes)
+    plus any of these named kwargs it asks for:
+      world    str    — the URL path that was written
+      version  int    — the new version after the write
+      pattern  str    — the registered pattern that matched
+      meta     dict   — X-Meta-* headers as a flat dict
+      e        Elastik— SDK client, pre-bound to the configured backend
+
+    Return: an Action, a list of Actions, or None.
+    """
+    def deco(func: Callable[..., Any]) -> Callable[..., Any]:
+        _routes[pattern] = func
+        return func
+    return deco
+
+
+def _matches(pattern: str, path: str) -> bool:
+    if pattern == "*":
+        return True
+    if pattern.endswith("*"):
+        return path.startswith(pattern[:-1])
+    return path == pattern
+
+
+# ── actions (intent objects) ───────────────────────────────────────
+
+class Action:
+    """Base. Subclasses describe intent; .execute(ctx) does the work."""
+
+    def execute(self, ctx: Ctx) -> None:
+        raise NotImplementedError
+
+
+class MoveTo(Action):
+    """Write to dest, then delete the source."""
+
+    def __init__(self, dest: str, **meta: Any):
+        self.dest = dest
+        self.meta = meta
+
+    def execute(self, ctx: Ctx) -> None:
+        ctx.e.put(self.dest, ctx.body, **self.meta)
+        ctx.e.delete(ctx.world)
+
+
+class Reply(Action):
+    """Write a new world. Source untouched."""
+
+    def __init__(self, dest: str, body: bytes | str, **meta: Any):
+        self.dest = dest
+        self.body = body
+        self.meta = meta
+
+    def execute(self, ctx: Ctx) -> None:
+        ctx.e.put(self.dest, self.body, **self.meta)
+
+
+class Archive(Action):
+    """Move source under prefix/<basename>."""
+
+    def __init__(self, prefix: str = "/home/archive/"):
+        self.prefix = prefix
+
+    def execute(self, ctx: Ctx) -> None:
+        name = ctx.world.rstrip("/").rsplit("/", 1)[-1] or "anon"
+        ctx.e.put(self.prefix.rstrip("/") + "/" + name, ctx.body)
+        ctx.e.delete(ctx.world)
+
+
+class Drop(Action):
+    """Delete the source. No reply."""
+
+    def execute(self, ctx: Ctx) -> None:
+        ctx.e.delete(ctx.world)
+
+
+# ── context passed to handlers + actions ────────────────────────────
+
+class Ctx:
+    __slots__ = ("body", "world", "version", "pattern", "meta", "e")
+
+    def __init__(self, body: bytes, world: str, version: int,
+                 pattern: str, meta: dict[str, str], e: Elastik):
+        self.body = body
+        self.world = world
+        self.version = version
+        self.pattern = pattern
+        self.meta = meta
+        self.e = e
+
+
+# ── core dispatch (used by both plugin and sidecar shape) ──────────
+
+def _call_handler(handler: Callable[..., Any], ctx: Ctx) -> Any:
+    """Pass only the kwargs the handler signature asks for."""
+    sig = inspect.signature(handler)
+    accepts = sig.parameters.keys()
+    candidates = {
+        "world": ctx.world,
+        "version": ctx.version,
+        "pattern": ctx.pattern,
+        "meta": ctx.meta,
+        "e": ctx.e,
+    }
+    kwargs = {k: v for k, v in candidates.items() if k in accepts}
+    has_var = any(
+        p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+    )
+    if has_var:
+        kwargs = candidates
+    return handler(ctx.body, **kwargs)
+
+
+def _run_action(result: Any, ctx: Ctx) -> None:
+    if result is None:
+        return
+    if isinstance(result, Action):
+        result.execute(ctx)
+        return
+    if isinstance(result, (list, tuple)):
+        for item in result:
+            if isinstance(item, Action):
+                item.execute(ctx)
+        return
+    # Anything else — ignored. Reactor is forgiving by design; the
+    # PUT response shouldn't fail because a handler returned a string.
+
+
+def _dispatch(world: str, body: bytes, version: int, meta: dict[str, str],
+              e: Elastik) -> None:
+    """Find every matching handler, run it, execute its action(s)."""
+    for pattern, handler in _routes.items():
+        if not _matches(pattern, world):
+            continue
+        ctx = Ctx(body=body, world=world, version=version,
+                  pattern=pattern, meta=meta, e=e)
+        try:
+            result = _call_handler(handler, ctx)
+            _run_action(result, ctx)
+        except Exception as ex:
+            print(f"  reactor [{pattern}] raised: "
+                  f"{type(ex).__name__}: {ex}", flush=True)
+
+
+# ── shape 1: emit ROUTES + handle for elastik-python plugin runtime ─
+
+def finalize(elastik_url: str = "http://localhost:3005",
+             token: str = "") -> tuple[list[str], Callable]:
+    """Return (ROUTES, handle) for an elastik-python plugin.
+
+    Use at the bottom of a plugin file:
+
+        from sdk.reactor import listen, MoveTo, finalize
+        @listen("/home/inbox/*")
+        def triage(body): return MoveTo("/home/archive/")
+        ROUTES, handle = finalize()
+    """
+    e = Elastik(elastik_url, token=token)
+    routes = list(_routes.keys())
+
+    async def handle(method: str, body: Any, params: dict) -> dict:
+        if method != "PUT":
+            return {"_status": 200, "ok": True, "skipped": method}
+        scope = params.get("_scope", {})
+        world = scope.get("path", "")
+        version = int(scope.get("_version", 0))
+        meta = {
+            k.decode().lower(): v.decode()
+            for k, v in scope.get("headers", [])
+            if k.decode().lower().startswith("x-meta-")
+        }
+        body_bytes = body if isinstance(body, (bytes, bytearray)) else \
+            (body or "").encode("utf-8")
+        _dispatch(world, body_bytes, version, meta, e)
+        return {"_status": 200, "ok": True}
+
+    return routes, handle
+
+
+# ── shape 2: standalone sidecar HTTP server ────────────────────────
+
+def serve(host: str = "127.0.0.1", port: int = 3200,
+          elastik_url: str = "http://localhost:3105",
+          token: str = "") -> None:
+    """Run an HTTP server that elastik-core's fanout posts to.
+
+    elastik-core sends:
+      POST /<anything>
+      X-Elastik-World: <url path>
+      X-Elastik-Version: <int>
+      X-Elastik-Pattern: <matched pattern>
+      X-Meta-*: <forwarded>
+      body: the original PUT body
+    """
+    e = Elastik(elastik_url, token=token)
+    state = {"e": e}
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_POST(self):
+            n = int(self.headers.get("Content-Length", "0"))
+            body = self.rfile.read(n)
+            world = self.headers.get("X-Elastik-World", "")
+            version = int(self.headers.get("X-Elastik-Version", "0") or "0")
+            pattern = self.headers.get("X-Elastik-Pattern", "")
+            meta = {
+                k.lower(): v for k, v in self.headers.items()
+                if k.lower().startswith("x-meta-")
+            }
+            # reactor matches all registered patterns against the world,
+            # not just the one elastik-core sent (X-Elastik-Pattern is
+            # informational — one elastik-core listener URL may serve
+            # many @listen patterns in one process).
+            _dispatch(world, body, version, meta, state["e"])
+            self.send_response(200)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+
+        # Quiet by default
+        def log_message(self, *_): pass
+
+    srv = http.server.ThreadingHTTPServer((host, port), Handler)
+    print(f"reactor sidecar listening on http://{host}:{port}/", flush=True)
+    print(f"  elastik backend: {elastik_url}", flush=True)
+    print(f"  registered patterns: {list(_routes.keys())}", flush=True)
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        srv.shutdown()

elastik/sdk.py

@@ -0,0 +1,129 @@
+"""L1 — atom bindings for elastik-core.
+
+This is the SDK. It is not the frontend. The frontend is what you build
+*with* these atoms (see sdk.reactor + your own scripts).
+
+`e.put("/home/x", data)` is "Lumos" — a declaration. Underneath, the
+runtime may store, audit, fan out, broadcast, cache, log. The caller
+says three words.
+
+stdlib only — no httpx, no requests. urllib + json. ~80 lines.
+"""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+class ElastikError(Exception):
+    def __init__(self, status: int, body: bytes):
+        self.status = status
+        self.body = body
+        super().__init__(f"elastik {status}: {body[:200]!r}")
+
+
+class Elastik:
+    """Pythonic bindings to elastik-core's HTTP atoms.
+
+    >>> e = Elastik("http://localhost:3105", token="t2")
+    >>> e.put("/home/note", b"hello")           # PUT, returns dict
+    >>> e.get("/home/note", raw=True)           # GET ?raw, returns bytes
+    >>> e.head("/home/note")                    # HEAD, returns headers dict
+    >>> e.delete("/home/note")                  # DELETE
+    >>> e.list()                                # GET /proc/worlds
+    """
+
+    def __init__(self, url: str = "http://localhost:3005", token: str = ""):
+        self.url = url.rstrip("/")
+        self.token = token
+
+    # ── atoms ──────────────────────────────────────────────────────
+
+    def put(self, path: str, data: bytes | str, **meta: Any) -> dict:
+        """PUT body to path. kwargs become X-Meta-* headers."""
+        body = data.encode("utf-8") if isinstance(data, str) else data
+        headers = {f"X-Meta-{k.replace('_', '-')}": str(v) for k, v in meta.items()}
+        return self._json("PUT", path, body, headers)
+
+    def get(self, path: str, raw: bool = False) -> Any:
+        """GET path. raw=True returns bytes; otherwise the JSON envelope."""
+        suffix = "?raw" if raw else ""
+        status, _, body = self._raw("GET", path + suffix)
+        if status == 404:
+            raise ElastikError(404, body)
+        if status >= 400:
+            raise ElastikError(status, body)
+        if raw:
+            return body
+        return json.loads(body)
+
+    def head(self, path: str) -> dict[str, str]:
+        """HEAD path. Returns headers as a lowercased dict."""
+        status, headers, _ = self._raw("HEAD", path)
+        if status == 404:
+            raise ElastikError(404, b"")
+        return headers
+
+    def delete(self, path: str) -> bool:
+        """DELETE path. Returns True on 204, False on 404."""
+        status, _, _ = self._raw("DELETE", path)
+        if status == 204:
+            return True
+        if status == 404:
+            return False
+        raise ElastikError(status, b"")
+
+    def list(self) -> list[str]:
+        """GET /proc/worlds. Returns list of world names."""
+        status, _, body = self._raw("GET", "/proc/worlds")
+        if status >= 400:
+            raise ElastikError(status, body)
+        return [w["name"] for w in json.loads(body)]
+
+    def shaped(self, path: str, accept: str = "text/html",
+               intent: str = "") -> bytes:
+        """GET /shaped/<path> with Accept + X-Semantic-Intent. Forwards
+        to whatever shaper sidecar elastik routes /shaped/ to. Bytes back."""
+        headers = {"Accept": accept}
+        if intent:
+            headers["X-Semantic-Intent"] = intent
+        status, _, body = self._raw("GET", f"/shaped{path}", headers=headers)
+        if status >= 400:
+            raise ElastikError(status, body)
+        return body
+
+    # ── transport ─────────────────────────────────────────────────
+
+    def _raw(self, method: str, path: str, body: bytes | None = None,
+             headers: dict[str, str] | None = None) -> tuple[int, dict[str, str], bytes]:
+        url = self.url + (path if path.startswith("/") else "/" + path)
+        h = dict(headers or {})
+        if self.token:
+            h.setdefault("Authorization", f"Bearer {self.token}")
+        req = urllib.request.Request(url, data=body, method=method, headers=h)
+        try:
+            with urllib.request.urlopen(req, timeout=30) as r:
+                return (
+                    r.status,
+                    {k.lower(): v for k, v in r.headers.items()},
+                    r.read(),
+                )
+        except urllib.error.HTTPError as e:
+            return (
+                e.code,
+                {k.lower(): v for k, v in (e.headers or {}).items()},
+                e.read() if e.fp else b"",
+            )
+
+    def _json(self, method: str, path: str, body: bytes | None,
+              headers: dict[str, str] | None = None) -> dict:
+        status, _, raw = self._raw(method, path, body, headers)
+        if status >= 400:
+            raise ElastikError(status, raw)
+        try:
+            return json.loads(raw)
+        except (ValueError, json.JSONDecodeError):
+            return {"raw": raw}

elastik-0.0.1.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: elastik
+Version: 0.0.1
+Summary: Pastebin with HMAC that accidentally became a web OS. pip install one ring.
+Author: Ranger Chen
+License: MIT
+Project-URL: Homepage, https://github.com/rangersui/Elastik
+Project-URL: Repository, https://github.com/rangersui/Elastik
+Keywords: http,pastebin,local-first,ai,web-os,rust
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# elastik
+
+> `pip install elastik` — and you get a Rust web OS pretending to be a Python module.
+
+Same trick as NumPy: the `.whl` ships a precompiled binary inside the
+package; the Python layer is a thin client. You write Python; a Rust
+server does the work; you never see Cargo.
+
+```python
+import elastik
+
+e = elastik.start(token="x")              # spawn bundled rust core
+e.put("/home/note", "hello")
+print(e.get("/home/note", raw=True))      # b'hello'
+elastik.stop()
+```
+
+Module-level too — point at any running elastik via `ELASTIK_URL`:
+
+```python
+import elastik
+elastik.put("/home/note", "hi")
+print(elastik.get("/home/note", raw=True))
+```
+
+Reactor (declarative event handlers):
+
+```python
+import elastik
+
+@elastik.listen("/home/inbox/*")
+def triage(body, world, meta):
+    if b"urgent" in body:
+        return elastik.Reply(f"/home/alerts/{world.rsplit('/',1)[-1]}", body)
+    return elastik.Archive()
+
+elastik.serve(port=3200)
+```
+
+Set elastik-core to fan out to that port:
+
+```bash
+ELASTIK_LISTENERS="/home/inbox/*=http://localhost:3200/triage" \
+    elastik run --port 3105 --token t
+```
+
+## Install
+
+```bash
+pip install elastik
+```
+
+(For now: build from source — see "Build from source" below.)
+
+## CLI
+
+```bash
+elastik info                  # show bundled-binary path + size
+elastik run --port 3105       # spawn the bundled core, block
+```
+
+## What's bundled
+
+- **Rust binary** at `elastik/_bin/elastik-core[.exe]`
+  - HTTP + SQLite + HMAC + auth + harvard gate + listener fanout
+  - ~4.3 MB stripped
+  - source: `Elastik-server/Elastik-core/`
+- **Python SDK** (`elastik.sdk.Elastik`)
+  - atom bindings: `put`, `get`, `head`, `delete`, `list`, `shaped`
+  - stdlib only (urllib + json), no requests / httpx
+- **Python reactor sugar** (`elastik.reactor`)
+  - `@listen(pattern)` decorator
+  - `MoveTo`, `Reply`, `Archive`, `Drop` action classes
+  - two deployment shapes: as elastik-python plugin (`finalize()`),
+    or as standalone sidecar (`serve()`)
+
+## The PyTorch parallel
+
+| layer | what | who writes |
+|---|---|---|
+| L0 — Rust core | bedrock atoms (HTTP/SQLite/HMAC) | one human, once |
+| L1 — Python SDK | `elastik.put`, `elastik.get`, … | AI, once |
+| L1.5 — plugin runtime | (in elastik-server, hot-reload) | already exists |
+| L2 — reactor sugar | `@elastik.listen` + Action classes | AI, once |
+| L3 — agent programs | composition: if/for + L1 + L2 + ai | AI, daily |
+
+`elastik.put()` is `np.array()`. The frontend isn't this call — it's
+what you compose with these atoms. See [Elastik-core/README.md] for
+the full architecture.
+
+## Build from source
+
+```bash
+# 1. build the rust core
+cd Elastik-core
+cargo build --release
+
+# 2. drop the binary into the python package
+cp target/release/elastik-core* ../elastik-pip/src/elastik/_bin/
+
+# 3. install the python package
+cd ../elastik-pip
+pip install -e .
+```
+
+Then:
+
+```bash
+python -c "import elastik; e = elastik.start(); print(e.put('/home/x', 'hi'))"
+```
+
+## Status
+
+Sketch. One platform at a time (this build is for the host you ran
+`cargo build` on). Multi-platform wheels via `cibuildwheel` is the
+next step.
+
+## License
+
+MIT.

elastik-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+elastik/__init__.py,sha256=Jz7gbBLvz-vAxDjJzOigbZov-6mfnV3reH7oAl_UH-c,4716
+elastik/__main__.py,sha256=sWVfw-_KE4h5PexCVTfwmn4tqNen-XOyssEyBKL8NrE,2017
+elastik/_spawn.py,sha256=PH_wYunv9PRhxwSXi2k7Qg3vdzB4Hdtkbe6nec778qc,4422
+elastik/reactor.py,sha256=lZhac69xjUqLMxMGh9bM1U280J8h1lx0Hwza7Vmb800,9466
+elastik/sdk.py,sha256=9n34SAhFxF4bWJtgTdIKiZICF15RBZNyjlZpueq4oKo,5138
+elastik/_bin/elastik-core.exe,sha256=dGY9pCRVty7yfbSKLBvyfIGg3F6FyVrWScJxeWcAYQw,4459008
+elastik-0.0.1.dist-info/METADATA,sha256=4m_upx-ZCl1Vw2EPMxl67DEJQPjFDH0qdLXX7EeC9AE,4074
+elastik-0.0.1.dist-info/WHEEL,sha256=QR8DNjG6Lr6bNErJWJgF4dP2dJ2N7NpY-BWly1OvcTM,97
+elastik-0.0.1.dist-info/entry_points.txt,sha256=fCrNw6tXUegXaxbef2tOBuh7bKnYixVipJlIAEtNdXM,50
+elastik-0.0.1.dist-info/top_level.txt,sha256=noR3uFxC-xJg60tpDis-duq7JsNUwkYM4Zw626omNzM,8
+elastik-0.0.1.dist-info/RECORD,,

elastik-0.0.1.dist-info/WHEEL

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

elastik-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+elastik = elastik.__main__:main

elastik-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+elastik