autooptm 0.1.0__tar.gz

autooptm-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+node_modules/
+.wrangler/
+.dev.vars
+.dev.vars.*
+!.dev.vars.example
+.DS_Store
+dist/
+.env
+.env.*
+*.pyc
+__pycache__/
+.claude/settings.local.json

autooptm-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: autooptm
+Version: 0.1.0
+Summary: Client, CLI and MCP server for AutoOptm — measured GPU speedups for your training and inference code
+License: MIT
+Requires-Python: >=3.9
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# autooptm
+
+Measured GPU speedups for your training and inference code — from the
+terminal, an agent, or Python. Diagnosis and measurement are free; credits
+move only when you unlock the patch.
+
+```bash
+pip install autooptm
+autooptm login                 # email code, no browser needed
+autooptm run https://github.com/you/repo --entrypoint train.py
+autooptm unlock <jobId>        # asks before spending credits
+git apply autooptm.patch
+```
+
+Python:
+
+```python
+from autooptm import AutoOptm
+ao = AutoOptm()
+job = ao.submit(".", entrypoint="bench.py", workload="inference")
+done = ao.wait(job["jobId"])
+print(done["speedup"], done["unlock_credits"])
+```
+
+MCP (Claude Code, Cursor, any MCP client) — `pip install 'autooptm[mcp]'`:
+
+```json
+{ "mcpServers": { "autooptm": { "command": "autooptm-mcp" } } }
+```
+
+Tools: `optimize_submit`, `optimize_status`, `optimize_wait`,
+`unlock_patch` (requires explicit user confirmation), `download_patch`,
+`account_balance`.

autooptm-0.1.0/README.md

@@ -0,0 +1,33 @@
+# autooptm
+
+Measured GPU speedups for your training and inference code — from the
+terminal, an agent, or Python. Diagnosis and measurement are free; credits
+move only when you unlock the patch.
+
+```bash
+pip install autooptm
+autooptm login                 # email code, no browser needed
+autooptm run https://github.com/you/repo --entrypoint train.py
+autooptm unlock <jobId>        # asks before spending credits
+git apply autooptm.patch
+```
+
+Python:
+
+```python
+from autooptm import AutoOptm
+ao = AutoOptm()
+job = ao.submit(".", entrypoint="bench.py", workload="inference")
+done = ao.wait(job["jobId"])
+print(done["speedup"], done["unlock_credits"])
+```
+
+MCP (Claude Code, Cursor, any MCP client) — `pip install 'autooptm[mcp]'`:
+
+```json
+{ "mcpServers": { "autooptm": { "command": "autooptm-mcp" } } }
+```
+
+Tools: `optimize_submit`, `optimize_status`, `optimize_wait`,
+`unlock_patch` (requires explicit user confirmation), `download_patch`,
+`account_balance`.

autooptm-0.1.0/autooptm/__init__.py

@@ -0,0 +1,185 @@
+"""AutoOptm client.
+
+Submit a repository (git URL or local directory), get a measured GPU
+speedup back, unlock the patch when the number convinces you.
+
+    from autooptm import AutoOptm
+    ao = AutoOptm()                        # token from AUTOOPTM_TOKEN
+    job = ao.submit("https://github.com/you/repo", entrypoint="train.py")
+    done = ao.wait(job["jobId"])
+    print(done["speedup"])                 # e.g. 1.87
+    ao.unlock(done["id"])                  # spends credits — ask first
+    ao.download_patch(done["id"], "autooptm.patch")
+
+The token is the session token the site stores after sign-in
+(localStorage key "ao.token"); it is valid for seven days.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Any, Optional
+
+__version__ = "0.1.0"
+
+DEFAULT_API = "https://api.autooptm.com"
+
+
+def _token_path() -> Path:
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "autooptm" / "token"
+
+
+def save_token(token: str) -> Path:
+    p = _token_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(token)
+    try:
+        p.chmod(0o600)
+    except OSError:
+        pass
+    return p
+
+
+def clear_token() -> None:
+    _token_path().unlink(missing_ok=True)
+
+# Never worth uploading: bulky, derived, or secret-bearing.
+_SKIP_DIRS = {".git", "__pycache__", ".venv", "venv", "node_modules",
+              ".mypy_cache", ".ruff_cache", ".pytest_cache", "wandb",
+              ".idea", ".vscode"}
+_SKIP_SUFFIXES = {".pt", ".pth", ".ckpt", ".safetensors", ".onnx", ".npz"}
+
+
+class AutoOptmError(RuntimeError):
+    def __init__(self, status: int, body: dict):
+        self.status = status
+        self.body = body
+        super().__init__(f"HTTP {status}: {body.get('error') or body}")
+
+
+class AutoOptm:
+    def __init__(self, token: Optional[str] = None, api: Optional[str] = None):
+        self.api = (api or os.environ.get("AUTOOPTM_API") or DEFAULT_API).rstrip("/")
+        stored = ""
+        try:
+            stored = _token_path().read_text().strip()
+        except OSError:
+            pass
+        self.token = token or os.environ.get("AUTOOPTM_TOKEN") or stored
+        if not self.token:
+            raise AutoOptmError(0, {
+                "error": "no_token",
+                "hint": "run `autooptm login` (email code, no browser needed) "
+                        "or export AUTOOPTM_TOKEN"})
+
+    # ------------------------------------------------------------- transport
+    def _req(self, method: str, path: str, body: Any = None,
+             raw: Optional[bytes] = None, content_type: str = "application/json"):
+        data = raw if raw is not None else (
+            json.dumps(body).encode() if body is not None else None)
+        r = urllib.request.Request(
+            self.api + path, data=data, method=method,
+            headers={"authorization": f"Bearer {self.token}",
+                     "content-type": content_type,
+                     # Cloudflare challenges the bare urllib agent (1010).
+                     "user-agent": f"autooptm-python/{__version__}"})
+        try:
+            with urllib.request.urlopen(r, timeout=120) as resp:
+                return json.loads(resp.read().decode() or "{}")
+        except urllib.error.HTTPError as e:
+            try:
+                payload = json.loads(e.read().decode() or "{}")
+            except Exception:
+                payload = {"error": f"http_{e.code}"}
+            raise AutoOptmError(e.code, payload) from None
+
+    # ------------------------------------------------------------------ api
+    def balance(self) -> dict:
+        return self._req("GET", "/api/balance")
+
+    def upload_dir(self, path: str) -> str:
+        """Zip a local directory (skipping caches, checkpoints, .git) and
+        upload it. Returns the storage key to pass to submit()."""
+        root = Path(path).resolve()
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+            for p in sorted(root.rglob("*")):
+                rel = p.relative_to(root)
+                if any(part in _SKIP_DIRS for part in rel.parts):
+                    continue
+                if p.is_file() and p.suffix.lower() not in _SKIP_SUFFIXES:
+                    z.write(p, str(rel))
+        blob = buf.getvalue()
+        out = self._req("POST", "/api/uploads", raw=blob,
+                        content_type="application/zip")
+        return out["key"]
+
+    def submit(self, source: str, entrypoint: str = "main.py",
+               workload: str = "training", gpu: Optional[str] = None,
+               args: Optional[str] = None, setup: Optional[str] = None,
+               git_ref: Optional[str] = None,
+               scale_args: Optional[str] = None) -> dict:
+        """Submit a git URL or a local directory for optimization.
+
+        Diagnosis and measurement are free of charge; credits move only
+        when the patch is unlocked."""
+        if "://" in source:
+            kind, src = "git", source
+        else:
+            kind, src = "zip", self.upload_dir(source)
+        body = {"sourceKind": kind, "source": src, "entrypoint": entrypoint,
+                "workload": workload}
+        for k, v in (("gpu", gpu), ("args", args), ("setup", setup),
+                     ("gitRef", git_ref), ("scaleArgs", scale_args)):
+            if v:
+                body[k] = v
+        return self._req("POST", "/api/jobs", body)
+
+    def job(self, job_id: str) -> dict:
+        out = self._req("GET", f"/api/jobs/{job_id}")
+        # The detail endpoint wraps the record: { job: {...}, events: [...] }.
+        job = out.get("job", out)
+        if isinstance(job, dict) and "events" in out:
+            job = {**job, "events": out["events"]}
+        return job
+
+    def wait(self, job_id: str, timeout_s: int = 3600, poll_s: int = 10) -> dict:
+        """Poll until the job finishes. Returns the final job record."""
+        deadline = time.time() + timeout_s
+        while True:
+            j = self.job(job_id)
+            if j.get("status") in ("succeeded", "failed", "canceled"):
+                return j
+            if time.time() > deadline:
+                raise AutoOptmError(0, {"error": "timeout", "jobId": job_id,
+                                        "lastStatus": j.get("status")})
+            time.sleep(poll_s)
+
+    def cancel(self, job_id: str) -> dict:
+        """Stop a queued or running job. Queued work dies immediately;
+        running work is asked to stop on its next heartbeat."""
+        return self._req("POST", "/api/jobs/cancel", {"jobId": job_id})
+
+    def unlock(self, job_id: str) -> dict:
+        """Accept the quoted price and open the patch. THIS SPENDS CREDITS."""
+        return self._req("POST", "/api/jobs/unlock", {"jobId": job_id})
+
+    def download_patch(self, job_id: str, dest: str = "autooptm.patch") -> str:
+        j = self.job(job_id)
+        url = j.get("patch_url")
+        if not url:
+            raise AutoOptmError(0, {"error": "patch_locked",
+                                    "hint": "call unlock() first"})
+        dl = urllib.request.Request(
+            url, headers={"user-agent": f"autooptm-python/{__version__}"})
+        with urllib.request.urlopen(dl, timeout=120) as r:
+            Path(dest).write_bytes(r.read())
+        return dest

autooptm-0.1.0/autooptm/cli.py

@@ -0,0 +1,160 @@
+"""`autooptm` CLI — submit, watch, unlock, download. One command each.
+
+    autooptm run https://github.com/you/repo --entrypoint train.py
+    autooptm run .  --entrypoint bench.py --gpu A10
+    autooptm status <jobId>
+    autooptm unlock <jobId> --yes
+    autooptm balance
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+from . import DEFAULT_API, AutoOptm, AutoOptmError, clear_token, save_token
+
+
+def _login(api: str, role: str | None) -> int:
+    email = input("email: ").strip()
+    if not email:
+        print("no email"); return 1
+
+    def post(path: str, body: dict) -> dict:
+        r = urllib.request.Request(api + path, method="POST",
+                                   data=json.dumps(body).encode(),
+                                   headers={"content-type": "application/json",
+                                            "user-agent": "autooptm-cli"})
+        with urllib.request.urlopen(r, timeout=60) as resp:
+            return json.loads(resp.read().decode() or "{}")
+
+    try:
+        started = post("/api/auth/email/start", {"email": email})
+    except urllib.error.HTTPError as e:
+        print("could not send the code: " + (e.read().decode() or str(e)))
+        return 1
+    code = started.get("devCode") or input("6-digit code from your inbox: ").strip()
+    body = {"email": email, "code": code}
+    if role:
+        body["role"] = role
+    try:
+        done = post("/api/auth/email/verify", body)
+    except urllib.error.HTTPError as e:
+        print("verify failed: " + (e.read().decode() or str(e)))
+        return 1
+    tok = done.get("token")
+    if not tok:
+        print("verify failed: " + json.dumps(done)); return 1
+    path = save_token(tok)
+    print(f"signed in as {email}; token saved to {path} (valid ~7 days)")
+    return 0
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="autooptm")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    run = sub.add_parser("run", help="submit a repo (git URL or local dir) and wait")
+    run.add_argument("source")
+    run.add_argument("--entrypoint", default="main.py")
+    run.add_argument("--workload", choices=["training", "inference"], default="training")
+    run.add_argument("--gpu", default=None)
+    run.add_argument("--args", dest="run_args", default=None)
+    run.add_argument("--setup", default=None)
+    run.add_argument("--git-ref", default=None)
+    run.add_argument("--no-wait", action="store_true")
+
+    st = sub.add_parser("status", help="one job's state")
+    st.add_argument("job_id")
+
+    ul = sub.add_parser("unlock", help="pay the quoted credits and download the patch")
+    ul.add_argument("job_id")
+    ul.add_argument("--yes", action="store_true", help="skip the confirmation prompt")
+    ul.add_argument("--out", default="autooptm.patch")
+
+    cx = sub.add_parser("cancel", help="stop a queued or running job")
+    cx.add_argument("job_id")
+
+    sub.add_parser("balance", help="credits available")
+
+    lg = sub.add_parser("login", help="sign in with an email code — no browser needed")
+    lg.add_argument("--role", default=None,
+                    choices=["researcher", "student", "engineer",
+                             "startup", "indie", "other"],
+                    help="optional: what you do (helps us build the right thing)")
+    sub.add_parser("logout", help="forget the saved token")
+
+    a = ap.parse_args(argv)
+    if a.cmd == "login":
+        api = (os.environ.get("AUTOOPTM_API") or DEFAULT_API).rstrip("/")
+        return _login(api, a.role)
+    if a.cmd == "logout":
+        clear_token()
+        print("token cleared")
+        return 0
+    try:
+        ao = AutoOptm()
+        if a.cmd == "balance":
+            b = ao.balance()
+            print(f"{b.get('total')} credits (≈ ${b.get('usdValue')})")
+        elif a.cmd == "run":
+            job = ao.submit(a.source, entrypoint=a.entrypoint, workload=a.workload,
+                            gpu=a.gpu, args=a.run_args, setup=a.setup,
+                            git_ref=a.git_ref)
+            print(f"job {job['jobId']} {job.get('status')}"
+                  + (" (free look)" if job.get("freeLook") else ""))
+            if not a.no_wait:
+                done = ao.wait(job["jobId"])
+                _print_result(done)
+        elif a.cmd == "cancel":
+            r = ao.cancel(a.job_id)
+            print(r.get("result", "ok"))
+        elif a.cmd == "status":
+            _print_result(ao.job(a.job_id))
+        elif a.cmd == "unlock":
+            j = ao.job(a.job_id)
+            price = j.get("unlock_credits")
+            if not a.yes:
+                ans = input(f"Unlock spends {price} credits. Continue? [y/N] ")
+                if ans.strip().lower() not in ("y", "yes"):
+                    print("aborted"); return 1
+            r = ao.unlock(a.job_id)
+            path = ao.download_patch(a.job_id, a.out)
+            print(f"charged {r.get('charged')} credits; patch -> {path}")
+            print("apply with: git apply " + path)
+        return 0
+    except AutoOptmError as e:
+        print(f"error: {e}", file=sys.stderr)
+        if e.body.get("hint"):
+            print("hint: " + str(e.body["hint"]), file=sys.stderr)
+        return 1
+
+
+def _print_result(j: dict) -> None:
+    s = j.get("status")
+    if s == "succeeded":
+        line = f"{j.get('speedup')}x"
+        if j.get("baseline_median") is not None:
+            line += (f"  ({j['baseline_median']}s -> "
+                     f"{j.get('optimised_median')}s)")
+        print(line)
+        if j.get("patch_unlocked"):
+            print("patch: unlocked")
+        elif j.get("unlock_credits") is not None:
+            print(f"patch: locked — unlock for {j['unlock_credits']} credits "
+                  f"(autooptm unlock {j.get('id')})")
+        if j.get("report_url"):
+            print("report: " + str(j["report_url"]))
+    elif s == "failed":
+        print(f"failed: {j.get('failure_reason')} — nothing charged")
+    else:
+        print(s)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

autooptm-0.1.0/autooptm/mcp_server.py

@@ -0,0 +1,118 @@
+"""MCP server: lets any MCP-capable agent (Claude Code, Cursor, ...) submit
+code to AutoOptm and bring back a measured speedup.
+
+Run:  AUTOOPTM_TOKEN=... autooptm-mcp          (stdio transport)
+
+Client config (e.g. .mcp.json):
+    { "mcpServers": { "autooptm": {
+        "command": "autooptm-mcp",
+        "env": { "AUTOOPTM_TOKEN": "..." } } } }
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError as e:  # pragma: no cover
+    raise SystemExit("install the extra first: pip install 'autooptm[mcp]'") from e
+
+from . import AutoOptm, AutoOptmError
+
+mcp = FastMCP("autooptm")
+
+
+def _client() -> AutoOptm:
+    return AutoOptm()
+
+
+def _err(e: AutoOptmError) -> dict:
+    return {"error": e.body.get("error", "request_failed"),
+            "hint": e.body.get("hint"), "status": e.status}
+
+
+@mcp.tool()
+def optimize_submit(source: str, entrypoint: str = "main.py",
+                    workload: str = "training", gpu: Optional[str] = None,
+                    args: Optional[str] = None, setup: Optional[str] = None,
+                    git_ref: Optional[str] = None) -> dict:
+    """Submit code to AutoOptm for GPU optimization. `source` is a public
+    git URL (github/gitlab) or a local directory path (zipped and uploaded,
+    skipping .git/caches/checkpoints). Diagnosis and measurement are free;
+    money moves only at unlock_patch. Returns {jobId, status}."""
+    try:
+        return _client().submit(source, entrypoint=entrypoint, workload=workload,
+                                gpu=gpu, args=args, setup=setup, git_ref=git_ref)
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def optimize_status(job_id: str) -> dict:
+    """Current state of a job: status, speedup, baseline/optimised medians,
+    unlock_credits (patch price), patch_unlocked, report_url."""
+    try:
+        return _client().job(job_id)
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def optimize_wait(job_id: str, timeout_s: int = 1800) -> dict:
+    """Block until the job finishes (succeeded/failed), polling every 10s.
+    A full optimization run typically takes tens of minutes."""
+    try:
+        return _client().wait(job_id, timeout_s=timeout_s)
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def optimize_cancel(job_id: str) -> dict:
+    """Stop a queued or running optimization. Queued jobs cancel at once;
+    running jobs stop at their next heartbeat. Nothing is charged."""
+    try:
+        return _client().cancel(job_id)
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def unlock_patch(job_id: str, confirmed_by_user: bool = False) -> dict:
+    """Pay the quoted credits and unlock the patch. SPENDS REAL CREDITS:
+    call only after the human has explicitly approved the price shown in
+    optimize_status (unlock_credits). Set confirmed_by_user=true to attest."""
+    if not confirmed_by_user:
+        return {"error": "confirmation_required",
+                "hint": "show the user unlock_credits and ask before paying"}
+    try:
+        return _client().unlock(job_id)
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def download_patch(job_id: str, dest: str = "autooptm.patch") -> dict:
+    """Download an unlocked patch to `dest`. Apply with `git apply`."""
+    try:
+        return {"path": _client().download_patch(job_id, dest)}
+    except AutoOptmError as e:
+        return _err(e)
+
+
+@mcp.tool()
+def account_balance() -> dict:
+    """Credits available on the signed-in AutoOptm account."""
+    try:
+        return _client().balance()
+    except AutoOptmError as e:
+        return _err(e)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

autooptm-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "autooptm"
+version = "0.1.0"
+description = "Client, CLI and MCP server for AutoOptm — measured GPU speedups for your training and inference code"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+# Zero runtime dependencies on purpose: the client is stdlib urllib.
+dependencies = []
+
+[project.optional-dependencies]
+mcp = ["mcp>=1.0"]
+
+[project.scripts]
+autooptm = "autooptm.cli:main"
+autooptm-mcp = "autooptm.mcp_server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["autooptm"]