runcloud-sdk 0.8.0__tar.gz → 0.8.2__tar.gz

{runcloud_sdk-0.8.0/runcloud_sdk.egg-info → runcloud_sdk-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runcloud-sdk
-Version: 0.8.0
+Version: 0.8.2
 Summary: Python SDK for run.cloud, including sandbox-provider compatibility adapters
 Author: Newly
 License-Expression: Apache-2.0

{runcloud_sdk-0.8.0 → runcloud_sdk-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runcloud-sdk"
-version = "0.8.0"
+version = "0.8.2"
 description = "Python SDK for run.cloud, including sandbox-provider compatibility adapters"
 readme = "README.md"
 requires-python = ">=3.9"

{runcloud_sdk-0.8.0 → runcloud_sdk-0.8.2}/runcloud/client.py

@@ -20,7 +20,8 @@ from websockets.sync.client import connect as websocket_connect
 Transport = Callable[[str, str, Any], Any]
 StreamTransport = Callable[[str, dict[str, Any]], Any]
 DEFAULT_API_URL = "https://api.run.cloud"
-USER_AGENT = "runcloud-python/0.8.0"
+USER_AGENT = "runcloud-python/0.8.2"
+FILE_CHUNK_BYTES = 512 * 1024
 
 
 class RunCloudError(Exception):
@@ -447,14 +448,87 @@ class Sandbox:
         )
 
     def read_file(self, path: str) -> bytes:
-        payload = self._client.request(
-            "POST",
-            f"/run-cloud/sandboxes/{urllib.parse.quote(self.id, safe='')}/fs",
-            {"op": "read", "path": path},
-        )
-        if payload.get("error"):
-            raise RunCloudError(0, str(payload["error"]))
-        return base64.b64decode(payload.get("content") or "")
+        if not path:
+            raise ValueError("path must not be empty")
+        sandbox_id = urllib.parse.quote(self.id, safe="")
+        chunks: list[bytes] = []
+        offset = 0
+        while True:
+            payload = self._client.request(
+                "POST",
+                f"/run-cloud/sandboxes/{sandbox_id}/fs",
+                {
+                    "op": "read",
+                    "path": path,
+                    "offset": offset,
+                    "length": FILE_CHUNK_BYTES,
+                },
+            )
+            if payload.get("error"):
+                raise RunCloudError(0, str(payload["error"]))
+            chunk = base64.b64decode(payload.get("content") or "")
+            chunks.append(chunk)
+            if payload.get("eof") is True:
+                return b"".join(chunks)
+            raw_next_offset = payload.get("next_offset")
+            raw_size = payload.get("size")
+            if (
+                payload.get("eof") is None
+                and raw_next_offset is None
+                and raw_size is None
+            ):
+                return b"".join(chunks)
+            next_offset = int(
+                raw_next_offset if raw_next_offset is not None else offset + len(chunk)
+            )
+            if raw_size is not None and next_offset >= int(raw_size):
+                return b"".join(chunks)
+            if next_offset <= offset:
+                raise RunCloudError(0, "file read did not advance")
+            offset = next_offset
+
+    def write_file(
+        self,
+        path: str,
+        content: bytes,
+        mode: Optional[int] = None,
+    ) -> None:
+        if not path:
+            raise ValueError("path must not be empty")
+        if not isinstance(content, bytes):
+            raise TypeError("content must be bytes")
+        sandbox_id = urllib.parse.quote(self.id, safe="")
+        chunk_count = max(1, (len(content) + FILE_CHUNK_BYTES - 1) // FILE_CHUNK_BYTES)
+        for index in range(chunk_count):
+            offset = index * FILE_CHUNK_BYTES
+            chunk = content[offset : offset + FILE_CHUNK_BYTES]
+            body: dict[str, Any] = {
+                "op": "write",
+                "path": path,
+                "offset": offset,
+                "content": base64.b64encode(chunk).decode(),
+                "truncate": index == 0,
+            }
+            if mode is not None:
+                body["mode"] = mode
+            payload = self._client.request(
+                "POST",
+                f"/run-cloud/sandboxes/{sandbox_id}/fs",
+                body,
+            )
+            if payload.get("error"):
+                raise RunCloudError(0, str(payload["error"]))
+            expected_next_offset = offset + len(chunk)
+            next_offset = payload.get("next_offset")
+            if chunk and (
+                isinstance(next_offset, bool)
+                or not isinstance(next_offset, int)
+                or next_offset != expected_next_offset
+            ):
+                raise RunCloudError(
+                    0,
+                    "file write chunk was not acknowledged; the file may be incomplete",
+                )
 
     def pause(self) -> "Sandbox":
         self._data = self._client.request(

{runcloud_sdk-0.8.0 → runcloud_sdk-0.8.2/runcloud_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runcloud-sdk
-Version: 0.8.0
+Version: 0.8.2
 Summary: Python SDK for run.cloud, including sandbox-provider compatibility adapters
 Author: Newly
 License-Expression: Apache-2.0

{runcloud_sdk-0.8.0 → runcloud_sdk-0.8.2}/tests/test_sdk.py

@@ -9,7 +9,7 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch
 
-from runcloud import Client, UnsupportedCompatibilityFeatureError
+from runcloud import Client, RunCloudError, UnsupportedCompatibilityFeatureError
 from runcloud.compat import modal
 from runcloud.compat.blaxel import SandboxInstance, SyncSandboxInstance
 from runcloud.compat.daytona import Daytona
@@ -30,6 +30,9 @@ class Recorder:
         if path.endswith("/exec"):
             return {"exit_code": 0, "stdout": "ok\n", "stderr": ""}
         if path.endswith("/fs"):
+            if body["op"] == "write":
+                chunk = base64.b64decode(body["content"])
+                return {"next_offset": body["offset"] + len(chunk)}
             return {"content": base64.b64encode(b"artifact").decode()}
         if path == "/run-cloud/sandboxes" and method == "GET":
             return {"items": [SANDBOX]}
@@ -111,6 +114,114 @@ class SDKTests(unittest.TestCase):
             self.recorder.calls,
         )
 
+    def test_exec_contract_defaults_legacy_true_and_preserves_false(self):
+        for frame, expected in [
+            ({"stream": "exit"}, 0),
+            ({"stream": "exit", "code": 1}, 1),
+        ]:
+            with self.subTest(frame=frame):
+                def stream_transport(_path, _body, exit_frame=frame):
+                    return iter([json.dumps(exit_frame)])
+
+                client = Client(
+                    api_key="rc_live_test",
+                    transport=self.recorder,
+                    stream_transport=stream_transport,
+                )
+                process = client.get("sb_python").exec_stream(
+                    "true" if expected == 0 else "false"
+                )
+                self.assertEqual(process.wait(), expected)
+
+    def test_read_file_downloads_all_chunks(self):
+        def transport(method, path, body):
+            if method == "GET":
+                return SANDBOX
+            self.assertEqual(method, "POST")
+            self.assertEqual(path, "/run-cloud/sandboxes/sb_python/fs")
+            if body["offset"] == 0:
+                return {
+                    "content": base64.b64encode(b"first").decode(),
+                    "next_offset": 5,
+                    "size": 11,
+                }
+            return {
+                "content": base64.b64encode(b"second").decode(),
+                "eof": True,
+                "next_offset": 11,
+                "size": 11,
+            }
+
+        box = Client(api_key="rc_live_test", transport=transport).get("sb_python")
+        self.assertEqual(box.read_file("/tmp/chunked"), b"firstsecond")
+
+    def test_write_file_uploads_binary_content_in_chunks(self):
+        box = self.client.create()
+        self.recorder.calls.clear()
+        content = b"a" * (512 * 1024) + b"tail"
+
+        box.write_file("/tmp/input.bin", content, mode=0o600)
+
+        writes = [body for method, path, body in self.recorder.calls if path.endswith("/fs")]
+        self.assertEqual(len(writes), 2)
+        self.assertEqual(
+            writes[0],
+            {
+                "op": "write",
+                "path": "/tmp/input.bin",
+                "offset": 0,
+                "content": base64.b64encode(content[: 512 * 1024]).decode(),
+                "truncate": True,
+                "mode": 0o600,
+            },
+        )
+        self.assertEqual(writes[1]["offset"], 512 * 1024)
+        self.assertEqual(base64.b64decode(writes[1]["content"]), b"tail")
+        self.assertFalse(writes[1]["truncate"])
+
+    def test_write_file_truncates_when_writing_an_empty_file(self):
+        box = self.client.create()
+        self.recorder.calls.clear()
+
+        box.write_file("/tmp/empty", b"")
+
+        self.assertEqual(
+            self.recorder.calls,
+            [
+                (
+                    "POST",
+                    "/run-cloud/sandboxes/sb_python/fs",
+                    {
+                        "op": "write",
+                        "path": "/tmp/empty",
+                        "offset": 0,
+                        "content": "",
+                        "truncate": True,
+                    },
+                ),
+            ],
+        )
+
+    def test_write_file_rejects_an_unacknowledged_continuation_chunk(self):
+        write_count = 0
+
+        def transport(method, path, body):
+            nonlocal write_count
+            if method == "GET":
+                return SANDBOX
+            self.assertEqual(path, "/run-cloud/sandboxes/sb_python/fs")
+            write_count += 1
+            if write_count == 1:
+                return {"next_offset": 512 * 1024}
+            return {}
+
+        box = Client(api_key="rc_live_test", transport=transport).get("sb_python")
+
+        with self.assertRaisesRegex(RunCloudError, "file write chunk was not acknowledged"):
+            box.write_file("/tmp/truncated.bin", b"a" * (512 * 1024) + b"tail")
+
+        self.assertEqual(write_count, 2)
+
     def test_compatibility_adapters_share_the_public_client(self):
         app = modal.App.lookup("compat", client=self.client)
         modal_sandbox = modal.Sandbox.create(app=app)
@@ -227,7 +338,7 @@ class SDKTests(unittest.TestCase):
             Client(api_key="rc_live_test").request("GET", "/run-cloud/account")
 
         request = urlopen.call_args.args[0]
-        self.assertEqual(request.get_header("User-agent"), "runcloud-python/0.8.0")
+        self.assertEqual(request.get_header("User-agent"), "runcloud-python/0.8.2")
 
     def test_exec_stream_opens_authenticated_websocket_and_sends_command(self):
         session = WebSocketSession()
@@ -257,7 +368,7 @@ class SDKTests(unittest.TestCase):
         connect.assert_called_once_with(
             "wss://api.example.test/run-cloud/sandboxes/sb_1/exec/stream?mode=command",
             additional_headers={"Authorization": "Bearer rc_live_test"},
-            user_agent_header="runcloud-python/0.8.0",
+            user_agent_header="runcloud-python/0.8.2",
             open_timeout=60.0,
             close_timeout=5,
             max_size=8 << 20,