Mimiry 0.2.1__tar.gz

mimiry-0.2.1/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: Mimiry
+Version: 0.2.1
+Summary: Python SDK for serverless compute
+Author-email: Oliver <oliversorensen39@gmail.com>
+License: Proprietary
+Project-URL: Homepage, https://mimiry.com
+Project-URL: Repository, https://github.com/OTSorensen/mimiry-python-sdk
+Project-URL: Issues, https://github.com/OTSorensen/mimiry-python-sdk/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: cloudpickle>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# mimiry — Python SDK for Mimiry GPU compute
+
+**Status:** alpha — early access
+**Backend:** softlaunch.mimiry.com (beta)
+
+Python-native interface for running serverless cloud GPU jobs on Mimiry, with full control over locality and providers.
+
+## Install
+
+```bash
+pip install mimiry
+```
+
+Or, for local development from a clone of this repo (editable install):
+
+```bash
+pip install -e .
+```
+
+## Auth
+
+Running jobs requires a Mimiry account. The SDK authenticates with SSH-JWT — the same SSH key you register on your account at the [Mimiry portal](https://softlaunch.mimiry.com). The fastest way to get set up is the interactive wizard, which generates a key (if needed), walks you through registering it in the portal, writes `MIMIRY_SSH_KEY` to your shell profile, and verifies the connection:
+
+```bash
+mimiry setup   # alias: mimiry init
+```
+
+This is a one-time step — you're set going forward.
+
+To configure auth manually instead, point the SDK at your private key:
+
+```bash
+export MIMIRY_SSH_KEY=~/.ssh/mimiry
+```
+
+Or pass `ssh_key_path=` explicitly to `mimiry.configure()`.
+
+## GPU types and providers
+
+Mimiry sources GPUs from both local datacenters and cloud providers across Europe and the US, spanning entry-level cards up to the latest high-end accelerators. You control locality and hardware requirements, as well as which providers to use.
+
+Always check what's currently available before selecting hardware:
+
+```bash
+mimiry availability
+```
+
+To filter to a single GPU family, add `--gpu-family <FAMILY>`.
+
+## Python version
+
+Your local Python `major.minor` must match the Python inside your container
+image. The SDK ships your function to the GPU with `cloudpickle`, which can't
+move code objects across Python versions — e.g. a function pickled on 3.12
+won't load on 3.10.
+
+You don't need to think about this with the default image: it ships Python
+3.12, matching recent Ubuntu / Debian / Fedora. It only matters if you set
+`image=` yourself — pick one whose `python3` matches your local interpreter.
+Confirm with `python3 --version` locally and inside the image; a mismatch
+shows up as a failure to deserialize your function.
+
+## Quickstart — one-shot function
+
+```python
+import mimiry
+
+@mimiry.function(
+    # Uses default hardware; run `mimiry availability` to choose a GPU/provider.
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+)
+def gpu_info():
+    import subprocess
+    return subprocess.check_output(
+        ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv"],
+        text=True,
+    )
+
+print(gpu_info.remote())
+```
+
+## Quickstart — raw bash command
+
+```python
+import mimiry
+
+result = mimiry.run(
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+    command="nvidia-smi",
+)
+print(result.logs)
+```
+
+## What works in this version
+
+- `@mimiry.function(gpu=..., image=...)` decorator
+- `.remote(*args, **kwargs)` — sync call, returns the function's return value
+- `.map(iterable)` — runs the function over an iterable, sequentially
+- `Image.from_registry(uri).pip_install(...).apt_install(...)` — basic image customisation (installs at container start; no real Dockerfile build)
+- `mimiry.run(image, gpu, command)` — raw bash entrypoint
+- SSH-JWT auth via existing key
+
+## Examples
+
+See `examples/`:
+
+- `01_hello.py` — minimal `nvidia-smi` on a GPU
+- `02_cuda_probe.py` — probe the GPU (driver, CUDA, device count) and return a structured Python dict
+- `03_bash_command.py` — run an arbitrary shell command with `mimiry.run()`

mimiry-0.2.1/README.md

@@ -0,0 +1,109 @@
+# mimiry — Python SDK for Mimiry GPU compute
+
+**Status:** alpha — early access
+**Backend:** softlaunch.mimiry.com (beta)
+
+Python-native interface for running serverless cloud GPU jobs on Mimiry, with full control over locality and providers.
+
+## Install
+
+```bash
+pip install mimiry
+```
+
+Or, for local development from a clone of this repo (editable install):
+
+```bash
+pip install -e .
+```
+
+## Auth
+
+Running jobs requires a Mimiry account. The SDK authenticates with SSH-JWT — the same SSH key you register on your account at the [Mimiry portal](https://softlaunch.mimiry.com). The fastest way to get set up is the interactive wizard, which generates a key (if needed), walks you through registering it in the portal, writes `MIMIRY_SSH_KEY` to your shell profile, and verifies the connection:
+
+```bash
+mimiry setup   # alias: mimiry init
+```
+
+This is a one-time step — you're set going forward.
+
+To configure auth manually instead, point the SDK at your private key:
+
+```bash
+export MIMIRY_SSH_KEY=~/.ssh/mimiry
+```
+
+Or pass `ssh_key_path=` explicitly to `mimiry.configure()`.
+
+## GPU types and providers
+
+Mimiry sources GPUs from both local datacenters and cloud providers across Europe and the US, spanning entry-level cards up to the latest high-end accelerators. You control locality and hardware requirements, as well as which providers to use.
+
+Always check what's currently available before selecting hardware:
+
+```bash
+mimiry availability
+```
+
+To filter to a single GPU family, add `--gpu-family <FAMILY>`.
+
+## Python version
+
+Your local Python `major.minor` must match the Python inside your container
+image. The SDK ships your function to the GPU with `cloudpickle`, which can't
+move code objects across Python versions — e.g. a function pickled on 3.12
+won't load on 3.10.
+
+You don't need to think about this with the default image: it ships Python
+3.12, matching recent Ubuntu / Debian / Fedora. It only matters if you set
+`image=` yourself — pick one whose `python3` matches your local interpreter.
+Confirm with `python3 --version` locally and inside the image; a mismatch
+shows up as a failure to deserialize your function.
+
+## Quickstart — one-shot function
+
+```python
+import mimiry
+
+@mimiry.function(
+    # Uses default hardware; run `mimiry availability` to choose a GPU/provider.
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+)
+def gpu_info():
+    import subprocess
+    return subprocess.check_output(
+        ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv"],
+        text=True,
+    )
+
+print(gpu_info.remote())
+```
+
+## Quickstart — raw bash command
+
+```python
+import mimiry
+
+result = mimiry.run(
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+    command="nvidia-smi",
+)
+print(result.logs)
+```
+
+## What works in this version
+
+- `@mimiry.function(gpu=..., image=...)` decorator
+- `.remote(*args, **kwargs)` — sync call, returns the function's return value
+- `.map(iterable)` — runs the function over an iterable, sequentially
+- `Image.from_registry(uri).pip_install(...).apt_install(...)` — basic image customisation (installs at container start; no real Dockerfile build)
+- `mimiry.run(image, gpu, command)` — raw bash entrypoint
+- SSH-JWT auth via existing key
+
+## Examples
+
+See `examples/`:
+
+- `01_hello.py` — minimal `nvidia-smi` on a GPU
+- `02_cuda_probe.py` — probe the GPU (driver, CUDA, device count) and return a structured Python dict
+- `03_bash_command.py` — run an arbitrary shell command with `mimiry.run()`

mimiry-0.2.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Mimiry"
+version = "0.2.1"
+description = "Python SDK for serverless compute"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Proprietary" }
+authors = [{ name = "Oliver", email = "oliversorensen39@gmail.com" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "httpx>=0.27",
+    "cloudpickle>=3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "ruff>=0.5",
+]
+
+[project.urls]
+Homepage = "https://mimiry.com"
+Repository = "https://github.com/OTSorensen/mimiry-python-sdk"
+Issues = "https://github.com/OTSorensen/mimiry-python-sdk/issues"
+
+[project.scripts]
+mimiry = "mimiry._cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

mimiry-0.2.1/setup.cfg

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

mimiry-0.2.1/src/Mimiry.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: Mimiry
+Version: 0.2.1
+Summary: Python SDK for serverless compute
+Author-email: Oliver <oliversorensen39@gmail.com>
+License: Proprietary
+Project-URL: Homepage, https://mimiry.com
+Project-URL: Repository, https://github.com/OTSorensen/mimiry-python-sdk
+Project-URL: Issues, https://github.com/OTSorensen/mimiry-python-sdk/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: cloudpickle>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# mimiry — Python SDK for Mimiry GPU compute
+
+**Status:** alpha — early access
+**Backend:** softlaunch.mimiry.com (beta)
+
+Python-native interface for running serverless cloud GPU jobs on Mimiry, with full control over locality and providers.
+
+## Install
+
+```bash
+pip install mimiry
+```
+
+Or, for local development from a clone of this repo (editable install):
+
+```bash
+pip install -e .
+```
+
+## Auth
+
+Running jobs requires a Mimiry account. The SDK authenticates with SSH-JWT — the same SSH key you register on your account at the [Mimiry portal](https://softlaunch.mimiry.com). The fastest way to get set up is the interactive wizard, which generates a key (if needed), walks you through registering it in the portal, writes `MIMIRY_SSH_KEY` to your shell profile, and verifies the connection:
+
+```bash
+mimiry setup   # alias: mimiry init
+```
+
+This is a one-time step — you're set going forward.
+
+To configure auth manually instead, point the SDK at your private key:
+
+```bash
+export MIMIRY_SSH_KEY=~/.ssh/mimiry
+```
+
+Or pass `ssh_key_path=` explicitly to `mimiry.configure()`.
+
+## GPU types and providers
+
+Mimiry sources GPUs from both local datacenters and cloud providers across Europe and the US, spanning entry-level cards up to the latest high-end accelerators. You control locality and hardware requirements, as well as which providers to use.
+
+Always check what's currently available before selecting hardware:
+
+```bash
+mimiry availability
+```
+
+To filter to a single GPU family, add `--gpu-family <FAMILY>`.
+
+## Python version
+
+Your local Python `major.minor` must match the Python inside your container
+image. The SDK ships your function to the GPU with `cloudpickle`, which can't
+move code objects across Python versions — e.g. a function pickled on 3.12
+won't load on 3.10.
+
+You don't need to think about this with the default image: it ships Python
+3.12, matching recent Ubuntu / Debian / Fedora. It only matters if you set
+`image=` yourself — pick one whose `python3` matches your local interpreter.
+Confirm with `python3 --version` locally and inside the image; a mismatch
+shows up as a failure to deserialize your function.
+
+## Quickstart — one-shot function
+
+```python
+import mimiry
+
+@mimiry.function(
+    # Uses default hardware; run `mimiry availability` to choose a GPU/provider.
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+)
+def gpu_info():
+    import subprocess
+    return subprocess.check_output(
+        ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv"],
+        text=True,
+    )
+
+print(gpu_info.remote())
+```
+
+## Quickstart — raw bash command
+
+```python
+import mimiry
+
+result = mimiry.run(
+    image="nvcr.io/nvidia/cuda:12.6.2-runtime-ubuntu24.04",
+    command="nvidia-smi",
+)
+print(result.logs)
+```
+
+## What works in this version
+
+- `@mimiry.function(gpu=..., image=...)` decorator
+- `.remote(*args, **kwargs)` — sync call, returns the function's return value
+- `.map(iterable)` — runs the function over an iterable, sequentially
+- `Image.from_registry(uri).pip_install(...).apt_install(...)` — basic image customisation (installs at container start; no real Dockerfile build)
+- `mimiry.run(image, gpu, command)` — raw bash entrypoint
+- SSH-JWT auth via existing key
+
+## Examples
+
+See `examples/`:
+
+- `01_hello.py` — minimal `nvidia-smi` on a GPU
+- `02_cuda_probe.py` — probe the GPU (driver, CUDA, device count) and return a structured Python dict
+- `03_bash_command.py` — run an arbitrary shell command with `mimiry.run()`

mimiry-0.2.1/src/Mimiry.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+src/Mimiry.egg-info/PKG-INFO
+src/Mimiry.egg-info/SOURCES.txt
+src/Mimiry.egg-info/dependency_links.txt
+src/Mimiry.egg-info/entry_points.txt
+src/Mimiry.egg-info/requires.txt
+src/Mimiry.egg-info/top_level.txt
+src/mimiry/__init__.py
+src/mimiry/__main__.py
+src/mimiry/_auth.py
+src/mimiry/_cli.py
+src/mimiry/_client.py
+src/mimiry/_config.py
+src/mimiry/_serialization.py
+src/mimiry/_session.py
+src/mimiry/_setup.py
+src/mimiry/_ssh.py
+src/mimiry/exceptions.py
+src/mimiry/function.py
+src/mimiry/image.py
+src/mimiry/run.py

mimiry-0.2.1/src/Mimiry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mimiry-0.2.1/src/Mimiry.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mimiry = mimiry._cli:main

mimiry-0.2.1/src/Mimiry.egg-info/requires.txt

@@ -0,0 +1,6 @@
+httpx>=0.27
+cloudpickle>=3.0
+
+[dev]
+pytest>=8
+ruff>=0.5

mimiry-0.2.1/src/Mimiry.egg-info/top_level.txt

@@ -0,0 +1 @@
+mimiry

mimiry-0.2.1/src/mimiry/__init__.py

@@ -0,0 +1,35 @@
+"""mimiry — Python SDK for Mimiry GPU compute (softlaunch).
+
+v0.2.0 — wraps the existing /api/compute/v1/sessions API. See README.md.
+"""
+
+from mimiry._config import configure, get_config
+from mimiry.exceptions import (
+    MimiryError,
+    AuthError,
+    SessionError,
+    SessionFailed,
+    SessionTimeout,
+    ResultParseError,
+)
+from mimiry.function import function, Function
+from mimiry.image import Image
+from mimiry.run import run
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "__version__",
+    "configure",
+    "get_config",
+    "function",
+    "Function",
+    "Image",
+    "run",
+    "MimiryError",
+    "AuthError",
+    "SessionError",
+    "SessionFailed",
+    "SessionTimeout",
+    "ResultParseError",
+]

mimiry-0.2.1/src/mimiry/__main__.py

@@ -0,0 +1,8 @@
+"""Enables ``python -m mimiry ...`` (notably ``python -m mimiry setup``)."""
+
+import sys
+
+from mimiry._cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

mimiry-0.2.1/src/mimiry/_auth.py

@@ -0,0 +1,188 @@
+"""SSH-JWT authentication against softlaunch.mimiry.com.
+
+Ports the algorithm from .claude/skills/mimiry-softlaunch/scripts/mimiry-auth.sh.
+We shell out to ``ssh-keygen`` for signing — implementing the SSH signature
+format in pure Python would mean re-deriving an OpenSSH-compatible format from
+the ``cryptography`` library, and ``ssh-keygen`` is universally available on
+the systems Mimiry users actually run on.
+
+Tokens last 1 hour (Mimiry default). The Token class refreshes itself when
+within 5 minutes of expiry.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import secrets
+import shutil
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from mimiry.exceptions import AuthError
+
+_TOKEN_REFRESH_BUFFER_SECONDS = 300  # refresh if < 5 min left
+_DEFAULT_TOKEN_TTL_SECONDS = 3600
+
+
+@dataclass
+class Token:
+    """A short-lived JWT issued by Mimiry. Self-refreshes when near expiry."""
+
+    access_token: str
+    expires_at: float  # unix seconds
+    fingerprint: str
+    ssh_key_path: Path
+    api_base: str
+
+    @property
+    def is_expired(self) -> bool:
+        return time.time() >= self.expires_at
+
+    @property
+    def is_near_expiry(self) -> bool:
+        return time.time() + _TOKEN_REFRESH_BUFFER_SECONDS >= self.expires_at
+
+    def refresh(self) -> "Token":
+        """Re-exchange the SSH signature for a fresh JWT. Mutates self."""
+        new = exchange_ssh_for_token(self.ssh_key_path, self.api_base)
+        self.access_token = new.access_token
+        self.expires_at = new.expires_at
+        return self
+
+    def get(self) -> str:
+        """Return the bearer string, refreshing if near expiry."""
+        if self.is_near_expiry:
+            self.refresh()
+        return self.access_token
+
+
+def _normalize_key_path(key_path: str | Path) -> Path:
+    """Accept either the private key path or the .pub path; return the private path."""
+    p = Path(key_path).expanduser()
+    if p.suffix == ".pub":
+        p = p.with_suffix("")
+    if not p.is_file():
+        raise AuthError(f"SSH private key not found: {p}")
+    if not p.with_suffix(p.suffix + ".pub").is_file() and not Path(f"{p}.pub").is_file():
+        raise AuthError(f"SSH public key not found: {p}.pub")
+    return p
+
+
+def _fingerprint(public_key_path: Path) -> str:
+    """Run ``ssh-keygen -lf`` to get the SHA256 fingerprint of a public key."""
+    if shutil.which("ssh-keygen") is None:
+        raise AuthError("ssh-keygen not found on PATH — required for Mimiry auth")
+    try:
+        out = subprocess.run(
+            ["ssh-keygen", "-lf", str(public_key_path)],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise AuthError(f"ssh-keygen -lf failed: {e.stderr.strip()}") from e
+    # Format: "<bits> <fingerprint> <comment> (<type>)"
+    parts = out.stdout.strip().split()
+    if len(parts) < 2:
+        raise AuthError(f"unexpected ssh-keygen output: {out.stdout!r}")
+    return parts[1]
+
+
+def _sign(message: bytes, private_key_path: Path) -> bytes:
+    """Sign ``message`` with the SSH key under the ``mimiry-auth`` namespace.
+
+    Returns the raw .sig file contents (OpenSSH SSHSIG format), as Mimiry expects.
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        msg_path = Path(tmpdir) / "msg"
+        msg_path.write_bytes(message)
+        try:
+            subprocess.run(
+                ["ssh-keygen", "-Y", "sign", "-f", str(private_key_path), "-n", "mimiry-auth",
+                 str(msg_path)],
+                capture_output=True,
+                check=True,
+            )
+        except subprocess.CalledProcessError as e:
+            raise AuthError(
+                f"ssh-keygen -Y sign failed: {e.stderr.decode(errors='replace').strip()}"
+            ) from e
+        sig_path = Path(f"{msg_path}.sig")
+        if not sig_path.is_file():
+            raise AuthError("ssh-keygen did not produce a .sig file")
+        return sig_path.read_bytes()
+
+
+def exchange_ssh_for_token(
+    ssh_key_path: str | Path,
+    api_base: str = "https://softlaunch.mimiry.com",
+) -> Token:
+    """Do the SSH-signature → JWT exchange. Returns a Token."""
+    api_base = api_base.rstrip("/")
+    priv = _normalize_key_path(ssh_key_path)
+    pub = Path(f"{priv}.pub")
+
+    fingerprint = _fingerprint(pub)
+    timestamp = str(int(time.time()))
+    nonce = secrets.token_hex(16)
+
+    message = f"{fingerprint}\n{timestamp}\n{nonce}".encode()
+    signature_bytes = _sign(message, priv)
+    signature_b64 = base64.b64encode(signature_bytes).decode()
+
+    try:
+        resp = httpx.post(
+            f"{api_base}/api/v1/auth/token",
+            headers={
+                "X-SSH-Fingerprint": fingerprint,
+                "X-SSH-Signature": signature_b64,
+                "X-SSH-Timestamp": timestamp,
+                "X-SSH-Nonce": nonce,
+                "Content-Type": "application/json",
+            },
+            json={"expires_in": _DEFAULT_TOKEN_TTL_SECONDS},
+            timeout=30.0,
+        )
+    except httpx.HTTPError as e:
+        raise AuthError(f"token exchange request failed: {e}") from e
+
+    if resp.status_code != 200:
+        raise AuthError(
+            f"token exchange returned {resp.status_code}: {resp.text[:500]}"
+        )
+
+    body = resp.json()
+    access_token = body.get("access_token")
+    if not access_token:
+        raise AuthError(f"token exchange response missing access_token: {body}")
+
+    expires_in = body.get("expires_in", _DEFAULT_TOKEN_TTL_SECONDS)
+    return Token(
+        access_token=access_token,
+        expires_at=time.time() + float(expires_in),
+        fingerprint=fingerprint,
+        ssh_key_path=priv,
+        api_base=api_base,
+    )
+
+
+def get_token(
+    ssh_key_path: str | Path | None = None,
+    api_base: str = "https://softlaunch.mimiry.com",
+) -> Token:
+    """Get a fresh Token. Falls back to ``MIMIRY_SSH_KEY`` env var when ``ssh_key_path`` is None."""
+    if ssh_key_path is None:
+        env_key = os.environ.get("MIMIRY_SSH_KEY")
+        if not env_key:
+            raise AuthError(
+                "no SSH key provided — pass ssh_key_path=, set MIMIRY_SSH_KEY env var, "
+                "or call mimiry.configure(ssh_key_path=...) first"
+            )
+        ssh_key_path = env_key
+    return exchange_ssh_for_token(ssh_key_path, api_base)