opensandbox 0.1.8.dev0__tar.gz → 0.1.8.dev1__tar.gz

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensandbox
-Version: 0.1.8.dev0
+Version: 0.1.8.dev1
 Summary: OpenSandbox Python SDK - Secure, isolated execution environments
 Project-URL: Homepage, https://open-sandbox.ai
 Project-URL: Repository, https://github.com/alibaba/OpenSandbox
@@ -453,9 +453,9 @@ Notes:
   lock owner and is not the pool identifier.
 - All nodes sharing one pool must use the same creation and warmup definition. If
   that definition changes, use a new `pool_name` or `key_prefix` and drain the old pool.
-- `resize(max_idle)` can be called from any node. The new idle target is stored in
-  the shared state store and the current primary applies replenish or shrink work
-  during reconcile.
+- `resize(max_idle)` can be called from any node. The call returns after the new
+  idle target is stored in the shared state store; the current primary applies
+  replenish or shrink work during periodic reconcile.
 - Use `resize(0)` and wait for `snapshot().idle_count == 0` to drain a distributed
   idle buffer. `release_all_idle()` is only a best-effort cleanup pass in distributed
   mode because another primary may put new idle sandboxes concurrently unless the

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/README.md

@@ -220,9 +220,9 @@ Notes:
   lock owner and is not the pool identifier.
 - All nodes sharing one pool must use the same creation and warmup definition. If
   that definition changes, use a new `pool_name` or `key_prefix` and drain the old pool.
-- `resize(max_idle)` can be called from any node. The new idle target is stored in
-  the shared state store and the current primary applies replenish or shrink work
-  during reconcile.
+- `resize(max_idle)` can be called from any node. The call returns after the new
+  idle target is stored in the shared state store; the current primary applies
+  replenish or shrink work during periodic reconcile.
 - Use `resize(0)` and wait for `snapshot().idle_count == 0` to drain a distributed
   idle buffer. `release_all_idle()` is only a best-effort cleanup pass in distributed
   mode because another primary may put new idle sandboxes concurrently unless the

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/src/opensandbox/adapters/converter/exception_converter.py

@@ -234,8 +234,11 @@ def _parse_error_body(body: Any) -> SandboxError | None:
                     message=body,
                 )
 
-        # Extract code and message from dict
+        # FastAPI HTTPException bodies are commonly wrapped as {"detail": {"code": ..., "message": ...}}.
         if isinstance(body, dict):
+            if isinstance(body.get("detail"), dict):
+                body = body["detail"]
+
             code: str | None = body.get("code")
             message: str | None = body.get("message")
 

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/src/opensandbox/adapters/converter/response_handler.py

@@ -28,7 +28,7 @@ import logging
 from http import HTTPStatus
 from typing import Any, TypeVar
 
-from opensandbox.exceptions import SandboxApiException
+from opensandbox.exceptions import SandboxApiException, SandboxError
 
 logger = logging.getLogger(__name__)
 
@@ -118,17 +118,27 @@ def handle_api_error(response_obj: Any, operation_name: str = "API call") -> Non
 
     if status_code >= 300:
         error_message = f"{operation_name} failed: HTTP {status_code}"
+        sandbox_error: SandboxError | None = None
 
         if hasattr(response_obj, "parsed") and response_obj.parsed is not None:
-            if hasattr(response_obj.parsed, "message"):
-                error_message = (
-                    f"{operation_name} failed: {response_obj.parsed.message}"
+            parsed = response_obj.parsed
+            parsed_code = getattr(parsed, "code", None)
+            parsed_message = getattr(parsed, "message", None)
+
+            if parsed_message:
+                error_message = f"{operation_name} failed: {parsed_message}"
+            elif parsed_code:
+                error_message = f"{operation_name} failed: {parsed_code}"
+
+            if parsed_code:
+                sandbox_error = SandboxError(
+                    code=str(parsed_code),
+                    message=str(parsed_message or ""),
                 )
-            elif hasattr(response_obj.parsed, "code"):
-                error_message = f"{operation_name} failed: {response_obj.parsed.code}"
 
         raise SandboxApiException(
             message=error_message,
             status_code=status_code,
             request_id=request_id,
+            error=sandbox_error,
         )

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/src/opensandbox/pool_async.py

@@ -135,10 +135,9 @@ class SandboxPoolAsync:
                 await self._state_store.set_idle_entry_ttl(
                     self._config.pool_name, self._config.idle_timeout
                 )
-                if await self._state_store.get_max_idle(self._config.pool_name) is None:
-                    await self._state_store.set_max_idle(
-                        self._config.pool_name, self._config.max_idle
-                    )
+                await self._state_store.set_max_idle(
+                    self._config.pool_name, self._config.max_idle
+                )
                 stop_event = asyncio.Event()
                 self._stop_event = stop_event
                 self._lifecycle_state = PoolLifecycleState.RUNNING
@@ -220,11 +219,6 @@ class SandboxPoolAsync:
             raise ValueError("max_idle must be >= 0")
         await self._state_store.set_max_idle(self._config.pool_name, max_idle)
         self._current_max_idle = max_idle
-        if self._lifecycle_state == PoolLifecycleState.RUNNING:
-            asyncio.create_task(
-                self._run_reconcile_tick(),
-                name=f"sandbox-pool-resize-{self._config.pool_name}",
-            )
 
     async def release_all_idle(self) -> int:
         pool_name = self._config.pool_name

{opensandbox-0.1.8.dev0 → opensandbox-0.1.8.dev1}/src/opensandbox/sync/pool.py

@@ -134,10 +134,9 @@ class SandboxPoolSync:
                 self._state_store.set_idle_entry_ttl(
                     self._config.pool_name, self._config.idle_timeout
                 )
-                if self._state_store.get_max_idle(self._config.pool_name) is None:
-                    self._state_store.set_max_idle(
-                        self._config.pool_name, self._config.max_idle
-                    )
+                self._state_store.set_max_idle(
+                    self._config.pool_name, self._config.max_idle
+                )
                 self._warmup_executor = ThreadPoolExecutor(
                     max_workers=max(1, int(self._config.warmup_concurrency or 1)),
                     thread_name_prefix=f"sandbox-pool-warmup-{self._config.pool_name}",
@@ -226,12 +225,6 @@ class SandboxPoolSync:
             raise ValueError("max_idle must be >= 0")
         self._state_store.set_max_idle(self._config.pool_name, max_idle)
         self._current_max_idle = max_idle
-        if self._lifecycle_state == PoolLifecycleState.RUNNING:
-            threading.Thread(
-                target=self._run_reconcile_tick,
-                name=f"sandbox-pool-resize-{self._config.pool_name}",
-                daemon=True,
-            ).start()
 
     def release_all_idle(self) -> int:
         pool_name = self._config.pool_name