withruntime 0.8.1__tar.gz → 0.8.2__tar.gz

{withruntime-0.8.1 → withruntime-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withruntime
-Version: 0.8.1
+Version: 0.8.2
 Summary: Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first.
 License: Apache-2.0
 Project-URL: Homepage, https://withruntime.com
@@ -73,7 +73,10 @@ list, glob, stat, move, remove, upload and download directories), `pause`,
 `wake`, `extend`, `update`, `keep_alive`, `fork` and `snapshot`, and the
 `interpreter`, `network`, `previews` and `desktop` 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. The client has `sandboxes`, `images`,
+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`, `limits`, `feedback` and `support`;
 `runtime.limits.get()` (0.3.1 and later) says whether the key is read-only and
 what its agent may still spend today. Every write carries an
@@ -159,8 +162,8 @@ How it maps:
   (every `/` becomes `-`; the tag is `latest` when none is given), so the
   code keeps Blaxel's image string. A missing one raises `NotSupportedError`
   with the build command, for example `npx withruntime image build
-  --dockerfile Dockerfile --name my-company-agent-image -t
-  my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
+--dockerfile Dockerfile --name my-company-agent-image -t
+my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
   name. On the free trial a sandbox has at most 4096 MB of memory (2 vCPUs).
 - **Standby.** A sandbox pauses after a minute with no call (Blaxel: about 15
   seconds). It keeps its memory and processes, and wakes on the next command,
@@ -200,8 +203,8 @@ Differences you can hit:
   (`/workspace`). File calls act as the sandbox user and fall back to `sudo`
   where only root may: they reach files a root process made, including private
   ones, and a file they write is the sandbox user's.
-- A sandbox is visible only to the key that created it: another key of the
-  same account gets 404 for it
+- A key sees the sandboxes it made, and another key's answer 404, unless an
+  owner or admin makes the key account-wide, as a Blaxel workspace key is
   ([teams](https://withruntime.com/docs/teams#keys-in-a-team)).
 - Public previews need a paid sandbox.
 - A process's `pid` is Runtime's process id, not an operating-system number.

{withruntime-0.8.1 → withruntime-0.8.2}/README.md

@@ -50,7 +50,10 @@ list, glob, stat, move, remove, upload and download directories), `pause`,
 `wake`, `extend`, `update`, `keep_alive`, `fork` and `snapshot`, and the
 `interpreter`, `network`, `previews` and `desktop` 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. The client has `sandboxes`, `images`,
+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`, `limits`, `feedback` and `support`;
 `runtime.limits.get()` (0.3.1 and later) says whether the key is read-only and
 what its agent may still spend today. Every write carries an
@@ -136,8 +139,8 @@ How it maps:
   (every `/` becomes `-`; the tag is `latest` when none is given), so the
   code keeps Blaxel's image string. A missing one raises `NotSupportedError`
   with the build command, for example `npx withruntime image build
-  --dockerfile Dockerfile --name my-company-agent-image -t
-  my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
+--dockerfile Dockerfile --name my-company-agent-image -t
+my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
   name. On the free trial a sandbox has at most 4096 MB of memory (2 vCPUs).
 - **Standby.** A sandbox pauses after a minute with no call (Blaxel: about 15
   seconds). It keeps its memory and processes, and wakes on the next command,
@@ -177,8 +180,8 @@ Differences you can hit:
   (`/workspace`). File calls act as the sandbox user and fall back to `sudo`
   where only root may: they reach files a root process made, including private
   ones, and a file they write is the sandbox user's.
-- A sandbox is visible only to the key that created it: another key of the
-  same account gets 404 for it
+- A key sees the sandboxes it made, and another key's answer 404, unless an
+  owner or admin makes the key account-wide, as a Blaxel workspace key is
   ([teams](https://withruntime.com/docs/teams#keys-in-a-team)).
 - Public previews need a paid sandbox.
 - A process's `pid` is Runtime's process id, not an operating-system number.

{withruntime-0.8.1 → withruntime-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "withruntime"
-version = "0.8.1"
+version = "0.8.2"
 description = "Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first."
 readme = "README.md"
 license = { text = "Apache-2.0" }

withruntime-0.8.2/tests/test_files_upload_parallel.py

@@ -0,0 +1,76 @@
+"""A large write keeps eight chunks in flight, in both client forms.
+
+Each chunk's reply waits on the API and the guest, so the link idles while
+every chunk in flight waits: four in flight took 100 MB 17-18 s from a
+12.6 MB/s home link, eight took 11 s (27 September 2026)."""
+import asyncio
+import threading
+import time
+import unittest
+from withruntime._async_client import AsyncFiles
+from withruntime._sync_client import Files
+
+MIB = 1048576
+
+
+class Counter:
+    def __init__(self):
+        self.now = self.most = self.chunks = 0
+        self.lock = threading.Lock()
+
+    def enter(self):
+        with self.lock:
+            self.now += 1
+            self.chunks += 1
+            self.most = max(self.most, self.now)
+
+    def leave(self):
+        with self.lock:
+            self.now -= 1
+
+
+class Transport:
+    def __init__(self):
+        self.count = Counter()
+
+    def json(self, method, path, body):
+        return {'uploadId': 'upload', 'chunkBytes': MIB} if path.endswith('/uploads') else {}
+
+    def send(self, method, path, **kwargs):
+        self.count.enter()
+        time.sleep(0.02)
+        self.count.leave()
+        return self
+
+    def read(self):
+        return b''
+
+
+class AsyncTransport(Transport):
+    async def json(self, *args, **kwargs):
+        return super().json(*args, **kwargs)
+
+    async def send(self, method, path, **kwargs):
+        self.count.enter()
+        await asyncio.sleep(0.02)
+        self.count.leave()
+        return self
+
+    async def read(self):
+        return b''
+
+
+class UploadParallel(unittest.TestCase):
+    def test_sync_keeps_eight_chunks_in_flight(self):
+        transport = Transport()
+        Files(transport, 'sandbox').write('/workspace/big.bin', b'x' * (16 * MIB))
+        self.assertEqual((transport.count.chunks, transport.count.most), (16, 8))
+
+    def test_async_keeps_eight_chunks_in_flight(self):
+        transport = AsyncTransport()
+        asyncio.run(AsyncFiles(transport, 'sandbox').write('/workspace/big.bin', b'x' * (16 * MIB)))
+        self.assertEqual((transport.count.chunks, transport.count.most), (16, 8))
+
+
+if __name__ == '__main__':
+    unittest.main()

{withruntime-0.8.1 → withruntime-0.8.2}/withruntime/_async_client.py

@@ -31,6 +31,11 @@ from ._async_products.watch import AsyncWatches, AsyncWatchHandle
 
 DEFAULT_BASE_URL = "https://api.withruntime.com"
 CHUNK = 1_048_576
+# Chunks of a large write in flight at once. Each chunk's reply waits on the
+# API and the guest, and the link idles while every chunk in flight waits: from
+# a home link (12.6 MB/s up, 27 September 2026) 100 MB took 17-18 s at four and
+# 11 s at eight, and sixteen was no faster. The TypeScript SDK sends eight too.
+PARALLEL_CHUNKS = 8
 _KEY_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789_.:-"
 
 
@@ -672,7 +677,7 @@ class AsyncFiles:
                                           raw=payload[offset:offset + step])
             await response.read()
         try:
-            await parallel(chunk, range(0, len(payload), step), 4)
+            await parallel(chunk, range(0, len(payload), step), PARALLEL_CHUNKS)
             await self._t.json("POST", self._path(f"/uploads/{_enc(upload)}:commit"), body={})
             if octal and begin.get("mode") != octal:  # Older images need chmod after commit.
                 await self._t.json("POST", self._path("/files:chmod"), body={"path": path, "mode": octal})
@@ -990,7 +995,8 @@ class AsyncSandbox:
         """Changes its settings; what you leave out stays as it is: ``name``,
         ``labels``, ``auto_wake`` (a request wakes it when paused),
         ``idle_pause_seconds`` (pause after this long with no activity, counted
-        from now; 0 never), ``persistent`` (keep it running while credit lasts
+        from now; 0 never, otherwise 10 to 86400; a new sandbox has 60),
+        ``persistent`` (keep it running while credit lasts
         and keep its disk after a stop; paid only) and
         ``max_total_cost_micros`` (None removes the cap)."""
         return await self._lifecycle("update", False, {_camel(k): v for k, v in settings.items()}, idempotency_key)
@@ -1287,7 +1293,7 @@ class AsyncRuntime:
         and ``takenBack`` (the part of spent that refunds and disputes took);
         ``trial`` is in milliseconds, or None; ``outbound`` is this month's
         outbound traffic in bytes, with ``chargedMicros`` for what went past
-        the free 100 GiB."""
+        the month's free ``allowanceBytes``."""
         return await self._t.json("GET", "/v1/usage")
 
     async def request(self, method: str, path: str, **kwargs: Any) -> Any:

{withruntime-0.8.1 → withruntime-0.8.2}/withruntime/_sync_client.py

@@ -30,6 +30,11 @@ from ._sync_products.watch import Watches, WatchHandle
 
 DEFAULT_BASE_URL = "https://api.withruntime.com"
 CHUNK = 1_048_576
+# Chunks of a large write in flight at once. Each chunk's reply waits on the
+# API and the guest, and the link idles while every chunk in flight waits: from
+# a home link (12.6 MB/s up, 27 September 2026) 100 MB took 17-18 s at four and
+# 11 s at eight, and sixteen was no faster. The TypeScript SDK sends eight too.
+PARALLEL_CHUNKS = 8
 _KEY_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789_.:-"
 
 
@@ -671,7 +676,7 @@ class Files:
                                           raw=payload[offset:offset + step])
             response.read()
         try:
-            parallel(chunk, range(0, len(payload), step), 4)
+            parallel(chunk, range(0, len(payload), step), PARALLEL_CHUNKS)
             self._t.json("POST", self._path(f"/uploads/{_enc(upload)}:commit"), body={})
             if octal and begin.get("mode") != octal:  # Older images need chmod after commit.
                 self._t.json("POST", self._path("/files:chmod"), body={"path": path, "mode": octal})
@@ -989,7 +994,8 @@ class Sandbox:
         """Changes its settings; what you leave out stays as it is: ``name``,
         ``labels``, ``auto_wake`` (a request wakes it when paused),
         ``idle_pause_seconds`` (pause after this long with no activity, counted
-        from now; 0 never), ``persistent`` (keep it running while credit lasts
+        from now; 0 never, otherwise 10 to 86400; a new sandbox has 60),
+        ``persistent`` (keep it running while credit lasts
         and keep its disk after a stop; paid only) and
         ``max_total_cost_micros`` (None removes the cap)."""
         return self._lifecycle("update", False, {_camel(k): v for k, v in settings.items()}, idempotency_key)
@@ -1286,7 +1292,7 @@ class Runtime:
         and ``takenBack`` (the part of spent that refunds and disputes took);
         ``trial`` is in milliseconds, or None; ``outbound`` is this month's
         outbound traffic in bytes, with ``chargedMicros`` for what went past
-        the free 100 GiB."""
+        the month's free ``allowanceBytes``."""
         return self._t.json("GET", "/v1/usage")
 
     def request(self, method: str, path: str, **kwargs: Any) -> Any:

withruntime-0.8.2/withruntime/_version.py

@@ -0,0 +1 @@
+VERSION = "0.8.2"

{withruntime-0.8.1 → withruntime-0.8.2}/withruntime/inspect_ai.py

@@ -274,7 +274,8 @@ class RuntimeSandboxEnvironment(SandboxEnvironment):
 
     @classmethod
     def default_concurrency(cls) -> Optional[int]:
-        # The free trial runs eight sandboxes at once; raise it with --max-sandboxes on a paid account.
+        # The free trial's concurrency, which packages/cloud-guide/src/facts.test.ts holds to
+        # the API's limit; raise it with --max-sandboxes on a paid account.
         return 8
 
     @classmethod

{withruntime-0.8.1 → withruntime-0.8.2}/withruntime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withruntime
-Version: 0.8.1
+Version: 0.8.2
 Summary: Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first.
 License: Apache-2.0
 Project-URL: Homepage, https://withruntime.com
@@ -73,7 +73,10 @@ list, glob, stat, move, remove, upload and download directories), `pause`,
 `wake`, `extend`, `update`, `keep_alive`, `fork` and `snapshot`, and the
 `interpreter`, `network`, `previews` and `desktop` 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. The client has `sandboxes`, `images`,
+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`, `limits`, `feedback` and `support`;
 `runtime.limits.get()` (0.3.1 and later) says whether the key is read-only and
 what its agent may still spend today. Every write carries an
@@ -159,8 +162,8 @@ How it maps:
   (every `/` becomes `-`; the tag is `latest` when none is given), so the
   code keeps Blaxel's image string. A missing one raises `NotSupportedError`
   with the build command, for example `npx withruntime image build
-  --dockerfile Dockerfile --name my-company-agent-image -t
-  my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
+--dockerfile Dockerfile --name my-company-agent-image -t
+my-company-agent-image:latest`. Volumes mount Runtime volumes of the same
   name. On the free trial a sandbox has at most 4096 MB of memory (2 vCPUs).
 - **Standby.** A sandbox pauses after a minute with no call (Blaxel: about 15
   seconds). It keeps its memory and processes, and wakes on the next command,
@@ -200,8 +203,8 @@ Differences you can hit:
   (`/workspace`). File calls act as the sandbox user and fall back to `sudo`
   where only root may: they reach files a root process made, including private
   ones, and a file they write is the sandbox user's.
-- A sandbox is visible only to the key that created it: another key of the
-  same account gets 404 for it
+- A key sees the sandboxes it made, and another key's answer 404, unless an
+  owner or admin makes the key account-wide, as a Blaxel workspace key is
   ([teams](https://withruntime.com/docs/teams#keys-in-a-team)).
 - Public previews need a paid sandbox.
 - A process's `pid` is Runtime's process id, not an operating-system number.

{withruntime-0.8.1 → withruntime-0.8.2}/withruntime.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ tests/test_eval_sandbox.py
 tests/test_exec_stream.py
 tests/test_files_download.py
 tests/test_files_mode.py
+tests/test_files_upload_parallel.py
 tests/test_harbor.py
 tests/test_http_tls_close.py
 tests/test_identity_token.py

withruntime-0.8.1/withruntime/_version.py

@@ -1 +0,0 @@
-VERSION = "0.8.1"