withruntime 0.8.3__tar.gz → 0.9.0__tar.gz

{withruntime-0.8.3/withruntime.egg-info → withruntime-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withruntime
-Version: 0.8.3
+Version: 0.9.0
 Summary: Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first.
 License: Apache-2.0
 Project-URL: Homepage, https://withruntime.com
@@ -11,6 +11,8 @@ Keywords: sandbox,ai-agents,agents,microvm,firecracker,code-execution,code-inter
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: e2b
+Requires-Dist: httpx<1.0.0,>=0.27.0; extra == "e2b"
 Provides-Extra: openai-agents
 Requires-Dist: openai-agents>=0.22.3; extra == "openai-agents"
 Provides-Extra: deepagents
@@ -70,15 +72,18 @@ asyncio.run(main())
 A sandbox has `exec`, `exec_stream`, `spawn`, `terminal`, `forward_port` (any
 TCP port in the sandbox on a local port), `files` (read, write,
 list, glob, stat, move, remove, upload and download directories), `pause`,
-`wake`, `extend`, `update`, `keep_alive`, `fork` and `snapshot`, and the
+`wake`, `extend`, `update` (its name, environment and settings), `keep_alive`,
+`fork`, `snapshot`, `switch_image` (move it to a new image keeping /workspace)
+and `delete` (remove it for good), and the
 `interpreter`, `network`, `previews`, `desktop`, `mounts` (your S3, R2 or Google
-Cloud Storage bucket as a folder), `metrics` and `mcp` (servers from the MCP
-catalog, run in the sandbox) products. A paused sandbox
+Cloud Storage bucket as a folder), `tailscale` (a paid sandbox on your own
+tailnet), `metrics` and `mcp` (servers from the MCP catalog, run in the
+sandbox) products. A paused sandbox
 also wakes by itself on the next call, and `Sandbox.get_or_create(name)` returns
 the sandbox with that name or creates it. A sandbox pauses itself after 60 seconds
 with nothing happening in it, keeping its memory and processes, so an
 idle sandbox costs no compute; `idle_pause_seconds` sets 10 to 86,400, or 0 for
-never. The client has `sandboxes`, `images`, `volumes`, `snapshots`,
+never. The client has `sandboxes`, `images`, `volumes`, `snapshots`, `jobs`,
 `secrets`, `limits`, `feedback` and `support`; `webhooks`, `events`, `otel` and
 `audit` to watch the account; `domains`, `ports`, `addresses`, `tunnel` and
 `network` to connect sandboxes to your own world (paid accounts); and `mcp`,

{withruntime-0.8.3 → withruntime-0.9.0}/README.md

@@ -47,15 +47,18 @@ asyncio.run(main())
 A sandbox has `exec`, `exec_stream`, `spawn`, `terminal`, `forward_port` (any
 TCP port in the sandbox on a local port), `files` (read, write,
 list, glob, stat, move, remove, upload and download directories), `pause`,
-`wake`, `extend`, `update`, `keep_alive`, `fork` and `snapshot`, and the
+`wake`, `extend`, `update` (its name, environment and settings), `keep_alive`,
+`fork`, `snapshot`, `switch_image` (move it to a new image keeping /workspace)
+and `delete` (remove it for good), and the
 `interpreter`, `network`, `previews`, `desktop`, `mounts` (your S3, R2 or Google
-Cloud Storage bucket as a folder), `metrics` and `mcp` (servers from the MCP
-catalog, run in the sandbox) products. A paused sandbox
+Cloud Storage bucket as a folder), `tailscale` (a paid sandbox on your own
+tailnet), `metrics` and `mcp` (servers from the MCP catalog, run in the
+sandbox) products. A paused sandbox
 also wakes by itself on the next call, and `Sandbox.get_or_create(name)` returns
 the sandbox with that name or creates it. A sandbox pauses itself after 60 seconds
 with nothing happening in it, keeping its memory and processes, so an
 idle sandbox costs no compute; `idle_pause_seconds` sets 10 to 86,400, or 0 for
-never. The client has `sandboxes`, `images`, `volumes`, `snapshots`,
+never. The client has `sandboxes`, `images`, `volumes`, `snapshots`, `jobs`,
 `secrets`, `limits`, `feedback` and `support`; `webhooks`, `events`, `otel` and
 `audit` to watch the account; `domains`, `ports`, `addresses`, `tunnel` and
 `network` to connect sandboxes to your own world (paid accounts); and `mcp`,

{withruntime-0.8.3 → withruntime-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "withruntime"
-version = "0.8.3"
+version = "0.9.0"
 description = "Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -19,6 +19,8 @@ Source = "https://github.com/withruntime/runtime/tree/main/sdks/python"
 Issues = "https://github.com/withruntime/runtime/issues"
 
 [project.optional-dependencies]
+# Preserve E2B's HTTP file-transfer timeout exception types.
+e2b = ["httpx>=0.27.0,<1.0.0"]
 # withruntime.openai_agents: a sandbox client for the OpenAI Agents SDK's SandboxAgent.
 openai-agents = ["openai-agents>=0.22.3"]
 # withruntime.deepagents: a LangChain Deep Agents sandbox backend.

{withruntime-0.8.3 → withruntime-0.9.0}/tests/test_client.py

@@ -8,6 +8,7 @@ import asyncio
 import inspect
 import json
 import os
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -98,17 +99,19 @@ class Sync(unittest.TestCase):
         self.assertEqual([s.id for s in page], [ID])
         self.assertFalse(page.has_more)
 
-    def test_directories_round_trip_through_tar(self):
-        # The fake guest cannot run tar; this proves the archive the SDK builds is safe to unpack.
-        import io, tarfile
-        buffer = io.BytesIO()
+    def test_a_folder_goes_in_and_comes_back_through_the_folder_routes(self):
+        # The fixture runs the real tar behind the API's folder routes: the
+        # upload is unpacked by the sandbox, the download packed by it.
+        sbx = client().sandboxes.get(ID)
+        noise = os.urandom(1_500_000)  # past 1 MiB compressed: sent in parts
         with tempfile.TemporaryDirectory() as root:
-            Path(root, "src").mkdir()
-            Path(root, "src", "a.py").write_text("print(1)\n")
-            with tarfile.open(fileobj=buffer, mode="w:gz") as archive:
-                archive.add(root, arcname=".")
-        with tarfile.open(fileobj=io.BytesIO(buffer.getvalue()), mode="r:gz") as archive:
-            self.assertIn("./src/a.py", archive.getnames())
+            Path(root, "up", "src").mkdir(parents=True)
+            Path(root, "up", "src", "a.py").write_text("print(1)\n")
+            Path(root, "up", "noise.bin").write_bytes(noise)
+            sbx.files.upload(str(Path(root, "up")), "/workspace/roundtrip")
+            sbx.files.download("/workspace/roundtrip", str(Path(root, "down")))
+            self.assertEqual(Path(root, "down", "src", "a.py").read_text(), "print(1)\n")
+            self.assertEqual(Path(root, "down", "noise.bin").read_bytes(), noise)
 
     def test_terminal_over_websocket(self):
         sbx = client().sandboxes.get(ID)
@@ -329,13 +332,39 @@ class Parity(unittest.TestCase):
             self.assertEqual(sync_methods, {m for m in async_methods if m in sync_methods | async_methods} & sync_methods | sync_methods)
             self.assertEqual(sorted(m for m in async_methods if not m.startswith("_")), sorted(sync_methods), name)
 
+    def test_import_leaves_heavy_modules_unloaded(self):
+        # asyncio is a third of the import budget and dataclasses brings inspect and
+        # tokenize: only the call that needs one should pay for it.
+        root = Path(__file__).resolve().parent.parent
+        loaded = subprocess.run([sys.executable, "-c", "import sys, withruntime; print(sorted(m for m in ('asyncio', 'concurrent.futures', 'dataclasses', 'inspect') if m in sys.modules))"],
+                                env={**os.environ, "PYTHONPATH": str(root)}, capture_output=True, text=True, check=True, timeout=10)
+        self.assertEqual(loaded.stdout.strip(), "[]")
+
+    @unittest.skipUnless(shutil.which("python3.10"), "python3.10 is not on PATH")
+    def test_the_oldest_supported_python_compiles_every_module(self):
+        # pyproject says 3.10; the suite runs on the newest python3, whose grammar
+        # accepts what 3.10 refuses (withruntime.blaxel did not import on 3.10 or 3.11).
+        package = Path(__file__).resolve().parent.parent / "withruntime"
+        code = ("import pathlib, sys\n"
+                "for path in sorted(pathlib.Path(sys.argv[1]).rglob('*.py')):\n"
+                "    compile(path.read_text(encoding='utf-8'), str(path), 'exec')\n")
+        result = subprocess.run([shutil.which("python3.10"), "-c", code, str(package)],
+                                capture_output=True, text=True, timeout=60)
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    @unittest.skipIf(os.environ.get("RUNTIME_IMPORT_AFTER") == "1", "run after all SDK language suites finish")
     def test_import_is_cheap(self):
+        from statistics import median
         code = "import time; t=time.perf_counter(); import withruntime; print((time.perf_counter()-t)*1000)"
         root = Path(__file__).resolve().parent.parent
-        subprocess.run([sys.executable, "-c", "import withruntime"], env={**os.environ, "PYTHONPATH": str(root)})
-        ms = float(subprocess.run([sys.executable, "-c", code], env={**os.environ, "PYTHONPATH": str(root)},
-                                  capture_output=True, text=True).stdout)
-        self.assertLess(ms, 60)
+        env = {**os.environ, "PYTHONPATH": str(root)}
+        subprocess.run([sys.executable, "-c", "import withruntime"], env=env, check=True, timeout=10)
+        # Fresh interpreters measure import work; the median prevents one scheduler
+        # interruption from deciding the budget without hiding sustained regressions.
+        samples = [float(subprocess.run([sys.executable, "-c", code], env=env,
+                                       capture_output=True, text=True, check=True, timeout=10).stdout)
+                   for _ in range(5)]
+        self.assertLess(median(samples), 60, f"import samples (ms): {samples}")
 
 
 @unittest.skipUnless(URL, "needs the fixture")

withruntime-0.9.0/tests/test_compat_live.py

@@ -0,0 +1,101 @@
+"""Opt-in trial-only Python adapter acceptance, never part of routine CI.
+
+RUNTIME_COMPAT_LIVE=1 PYTHONPATH=sdks/python python3 -m unittest discover \
+    -s sdks/python/tests -p test_compat_live.py
+
+Creates exactly one explicitly trial-funded native sandbox for at most 120 seconds.
+No image builds, persistent sandboxes, paid fallback, competitor calls, or existing
+customer resources. This proves commands/files/streams/reconnection, not each
+provider's create policy or image equivalence. Always stops the owned sandbox.
+"""
+import asyncio
+import hashlib
+import json
+import os
+import unittest
+import uuid
+from withruntime import Runtime, AsyncRuntime
+from withruntime._compat import ENV_PATH
+from withruntime.runloop import RunloopSDK, Runloop, AsyncRunloop
+from withruntime.prime import SandboxClient, AsyncSandboxClient
+from withruntime.sprites import SpritesClient, AsyncSpritesClient
+from withruntime.modal import Sandbox
+
+
+@unittest.skipUnless(os.environ.get("RUNTIME_COMPAT_LIVE") == "1", "Opt-in live trial acceptance only")
+class LiveTrial(unittest.TestCase):
+    def test_existing_sandbox_consumers(self):
+        api_key = os.environ.get("RUNTIME_API_KEY", "")
+        if not api_key.startswith("rtcloud_"):
+            raise ValueError("An explicit Runtime test API key is required; login fallback is disabled")
+        runtime = Runtime(api_key=api_key, wait_for_capacity=0)
+        usage = runtime.usage()
+        if (usage.get("trial") or {}).get("availableMs", 0) < 3_600_000:
+            runtime.close()
+            raise ValueError("At least one trial hour is required; no paid fallback")
+        name = "compat-python-" + uuid.uuid4().hex[:12]
+        sb = runtime.sandboxes.create(name=name, funding="trial", timeout_seconds=120,
+            idle_pause_seconds=0, on_lease_end="stop", labels={"compat.provider": "sprites"})
+        owned_id = sb.id
+        try:
+            self.assertEqual(sb.info.get("funding"), "trial", "Created sandbox must be trial-funded")
+            sb.files.write(ENV_PATH, json.dumps({"COMPAT_ENV": "persisted"}), mode=0o600)
+            runloop = RunloopSDK(runtime=runtime).devbox.from_id(sb.id)
+            result = runloop.cmd.exec("printf '%s' \"$COMPAT_ENV\"")
+            self.assertEqual((result.exit_code, result.stdout()), (0, "persisted"))
+            shell = runloop.shell("live-session")
+            shell.exec("mkdir -p /workspace/named && cd /workspace/named && export HELLO=world")
+            self.assertEqual(shell.exec('printf "%s:%s" "$PWD" "$HELLO"').stdout(), "/workspace/named:world")
+            reconnected = RunloopSDK(runtime=runtime).devbox.from_id(sb.id).shell("live-session")
+            self.assertEqual(reconnected.exec('printf "%s" "$HELLO"').stdout(), "world")
+            low = Runloop(runtime=runtime)
+            self.assertEqual(low.devboxes.execute_sync(sb.id, command="exit 7").exit_status, 7)
+            data = bytes(range(256)) * 4097
+            runloop.file.upload(path="/workspace/roundtrip", file=data)
+            self.assertEqual(hashlib.sha256(runloop.file.download(path="/workspace/roundtrip")).digest(), hashlib.sha256(data).digest())
+            prime = SandboxClient(runtime)
+            self.assertEqual(prime.execute_command(sb.id, 'printf "%s" "$COMPAT_ENV"').stdout, "persisted")
+            self.assertEqual(prime.execute_command(sb.id, "python3 -c 'print(\"x\"*100000,end=\"\")'").stdout, "x" * 100000)
+            prime.upload_bytes(sb.id, "/workspace/prime-text", "こんにちは".encode(), "prime-text")
+            self.assertEqual(prime.read_file(sb.id, "/workspace/prime-text").content, "こんにちは")
+            sprite = SpritesClient(runtime=runtime).get_sprite(name)
+            self.assertEqual(sprite.id, owned_id, "Only the sandbox created by this test may be used")
+            self.assertEqual(sprite.run("printf", "%s", "literal; data", capture_output=True).stdout, b"literal; data")
+            self.assertEqual(sprite.command("printf", "hello").output(), b"hello")
+            binary = sprite.command("python3", "-c", "import sys; sys.stdout.buffer.write(bytes(range(256)))").output()
+            self.assertEqual(binary, bytes(range(256)))
+            path = sprite.filesystem("/workspace") / "sprites-binary"
+            path.write_bytes(data)
+            self.assertEqual(path.read_bytes(), data)
+            modal = Sandbox.from_id(sb.id, client=runtime)
+            process = modal.exec("bash", "-c", "printf 'out'; printf 'err' >&2; exit 3")
+            self.assertEqual((process.stdout.read(), process.stderr.read(), process.wait()), ("out", "err", 3))
+            self._async_consumers(sb.id, name)
+        finally:
+            self.assertEqual(sb.id, owned_id)
+            sb.stop()
+            runtime.close()
+
+    def _async_consumers(self, sandbox_id, name):
+        async def run():
+            runtime = AsyncRuntime(api_key=os.environ["RUNTIME_API_KEY"], wait_for_capacity=0)
+            try:
+                low = AsyncRunloop(runtime=runtime)
+                self.assertEqual((await low.devboxes.execute_sync(sandbox_id, command="printf async")).stdout, "async")
+                prime = AsyncSandboxClient(runtime=runtime)
+                self.assertEqual((await prime.execute_command(sandbox_id, "printf prime")).stdout, "prime")
+                sprite = await AsyncSpritesClient(runtime=runtime).get_sprite(name)
+                self.assertEqual(sprite.id, sandbox_id)
+                self.assertEqual(await sprite.command("printf", "sprite").output(), b"sprite")
+                binary = await sprite.command("python3", "-c", "import sys; sys.stdout.buffer.write(bytes(range(256)))").output()
+                self.assertEqual(binary, bytes(range(256)))
+                modal = await Sandbox.from_id.aio(sandbox_id, client=runtime)
+                process = await modal.exec.aio("bash", "-c", "read line; printf '%s' \"$line\"")
+                process.stdin.write(b"input\n")
+                process.stdin.write_eof()
+                await process.stdin.drain.aio()
+                self.assertEqual(await process.stdout.read.aio(), "input")
+                self.assertEqual(await process.wait.aio(), 0)
+            finally:
+                await runtime.close()
+        asyncio.run(run())