opensandbox 0.1.8.dev2__tar.gz → 0.1.9.dev0__tar.gz

{opensandbox-0.1.8.dev2 → opensandbox-0.1.9.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensandbox
-Version: 0.1.8.dev2
+Version: 0.1.9.dev0
 Summary: OpenSandbox Python SDK - Secure, isolated execution environments
 Project-URL: Homepage, https://open-sandbox.ai
 Project-URL: Repository, https://github.com/alibaba/OpenSandbox

{opensandbox-0.1.8.dev2 → opensandbox-0.1.9.dev0}/pyproject.toml

@@ -67,7 +67,7 @@ source = "vcs"
 root = "../../.."
 tag_regex = "^python/sandbox/v(?P<version>\\d+\\.\\d+\\.\\d+(?:[\\.\\w\\+\\-]*)?)$"
 git_describe_command = 'git describe --dirty --tags --long --match "python/sandbox/v*"'
-fallback_version = "0.1.8"
+fallback_version = "0.1.9"
 
 [tool.hatch.build]
 include = [

{opensandbox-0.1.8.dev2 → opensandbox-0.1.9.dev0}/src/opensandbox/_pool_reconciler.py

@@ -31,8 +31,8 @@ logger = logging.getLogger(__name__)
 @dataclass
 class ReconcileState:
     degraded_threshold: int
-    backoff_base: timedelta = timedelta(seconds=1)
-    backoff_max: timedelta = timedelta(seconds=60)
+    backoff_base: timedelta = timedelta(seconds=30)
+    backoff_max: timedelta = timedelta(days=1)
     failure_count: int = 0
     state: PoolState = PoolState.HEALTHY
     last_error: str | None = None
@@ -53,7 +53,7 @@ class ReconcileState:
         if self.failure_count >= self.degraded_threshold:
             self.state = PoolState.DEGRADED
             self.backoff_attempts += 1
-            exponent = min(self.backoff_attempts, 10)
+            exponent = min(self.backoff_attempts - 1, 30)
             delay = min(
                 self.backoff_base.total_seconds() * (1 << exponent),
                 self.backoff_max.total_seconds(),

opensandbox-0.1.9.dev0/src/opensandbox/adapters/converter/diagnostic_model_converter.py

@@ -0,0 +1,31 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Converters for diagnostics API models."""
+
+from opensandbox.api.diagnostic.models import (
+    DiagnosticContentResponse as ApiDiagnosticContentResponse,
+)
+from opensandbox.models.diagnostics import DiagnosticContent
+
+
+class DiagnosticModelConverter:
+    """Convert generated diagnostics API models to public SDK models."""
+
+    @staticmethod
+    def to_diagnostic_content(
+        response: ApiDiagnosticContentResponse,
+    ) -> DiagnosticContent:
+        return DiagnosticContent.model_validate(response.to_dict())

opensandbox-0.1.9.dev0/src/opensandbox/adapters/diagnostics_adapter.py

@@ -0,0 +1,126 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Diagnostics service adapter implementation."""
+
+import logging
+
+import httpx  # type: ignore[reportMissingImports]
+
+from opensandbox.adapters.converter.diagnostic_model_converter import (
+    DiagnosticModelConverter,
+)
+from opensandbox.adapters.converter.exception_converter import ExceptionConverter
+from opensandbox.adapters.converter.response_handler import (
+    handle_api_error,
+    require_parsed,
+)
+from opensandbox.config import ConnectionConfig
+from opensandbox.models.diagnostics import DiagnosticContent
+from opensandbox.services.diagnostics import Diagnostics
+
+logger = logging.getLogger(__name__)
+
+
+class DiagnosticsAdapter(Diagnostics):
+    """Adapter for sandbox diagnostics management API operations."""
+
+    def __init__(self, connection_config: ConnectionConfig) -> None:
+        self.connection_config = connection_config
+        from opensandbox.api.diagnostic import AuthenticatedClient
+
+        api_key = self.connection_config.get_api_key()
+        timeout_seconds = self.connection_config.request_timeout.total_seconds()
+        timeout = httpx.Timeout(timeout_seconds)
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": self.connection_config.user_agent,
+            **self.connection_config.headers,
+        }
+        if api_key:
+            headers["OPEN-SANDBOX-API-KEY"] = api_key
+
+        self._client = AuthenticatedClient(
+            base_url=self.connection_config.get_base_url(),
+            token=api_key or "",
+            prefix="",
+            auth_header_name="OPEN-SANDBOX-API-KEY",
+            timeout=timeout,
+        )
+        self._httpx_client = httpx.AsyncClient(
+            base_url=self.connection_config.get_base_url(),
+            headers=headers,
+            timeout=timeout,
+            transport=self.connection_config.transport,
+        )
+        self._client.set_async_httpx_client(self._httpx_client)
+
+    async def _get_client(self):
+        return self._client
+
+    async def get_logs(
+        self,
+        sandbox_id: str,
+        scope: str,
+    ) -> DiagnosticContent:
+        try:
+            from opensandbox.api.diagnostic.api.diagnostics import (
+                get_sandboxes_sandbox_id_diagnostics_logs,
+            )
+            from opensandbox.api.diagnostic.models import DiagnosticContentResponse
+
+            response_obj = await get_sandboxes_sandbox_id_diagnostics_logs.asyncio_detailed(
+                sandbox_id=sandbox_id,
+                client=await self._get_client(),
+                scope=scope,
+            )
+            handle_api_error(response_obj, f"Get diagnostic logs for sandbox {sandbox_id}")
+            parsed = require_parsed(
+                response_obj,
+                DiagnosticContentResponse,
+                f"Get diagnostic logs for sandbox {sandbox_id}",
+            )
+            return DiagnosticModelConverter.to_diagnostic_content(parsed)
+        except Exception as e:
+            logger.error("Failed to get diagnostic logs for sandbox %s", sandbox_id, exc_info=e)
+            raise ExceptionConverter.to_sandbox_exception(e) from e
+
+    async def get_events(
+        self,
+        sandbox_id: str,
+        scope: str,
+    ) -> DiagnosticContent:
+        try:
+            from opensandbox.api.diagnostic.api.diagnostics import (
+                get_sandboxes_sandbox_id_diagnostics_events,
+            )
+            from opensandbox.api.diagnostic.models import DiagnosticContentResponse
+
+            response_obj = await get_sandboxes_sandbox_id_diagnostics_events.asyncio_detailed(
+                sandbox_id=sandbox_id,
+                client=await self._get_client(),
+                scope=scope,
+            )
+            handle_api_error(response_obj, f"Get diagnostic events for sandbox {sandbox_id}")
+            parsed = require_parsed(
+                response_obj,
+                DiagnosticContentResponse,
+                f"Get diagnostic events for sandbox {sandbox_id}",
+            )
+            return DiagnosticModelConverter.to_diagnostic_content(parsed)
+        except Exception as e:
+            logger.error("Failed to get diagnostic events for sandbox %s", sandbox_id, exc_info=e)
+            raise ExceptionConverter.to_sandbox_exception(e) from e

{opensandbox-0.1.8.dev2 → opensandbox-0.1.9.dev0}/src/opensandbox/adapters/factory.py

@@ -25,6 +25,7 @@ to ensure consistent pooling/proxy/retry behavior across services.
 """
 
 from opensandbox.adapters.command_adapter import CommandsAdapter
+from opensandbox.adapters.diagnostics_adapter import DiagnosticsAdapter
 from opensandbox.adapters.egress_adapter import EgressAdapter
 from opensandbox.adapters.filesystem_adapter import FilesystemAdapter
 from opensandbox.adapters.health_adapter import HealthAdapter
@@ -33,6 +34,7 @@ from opensandbox.adapters.sandboxes_adapter import SandboxesAdapter
 from opensandbox.config import ConnectionConfig
 from opensandbox.models.sandboxes import SandboxEndpoint
 from opensandbox.services.command import Commands
+from opensandbox.services.diagnostics import Diagnostics
 from opensandbox.services.egress import Egress
 from opensandbox.services.filesystem import Filesystem
 from opensandbox.services.health import Health
@@ -70,6 +72,10 @@ class AdapterFactory:
         """
         return SandboxesAdapter(self.connection_config)
 
+    def create_diagnostics_service(self) -> Diagnostics:
+        """Create a diagnostics service for sandbox troubleshooting operations."""
+        return DiagnosticsAdapter(self.connection_config)
+
     def create_filesystem_service(self, endpoint: SandboxEndpoint) -> Filesystem:
         """Create a filesystem service for file and directory operations.
 

{opensandbox-0.1.8.dev2 → opensandbox-0.1.9.dev0}/src/opensandbox/adapters/sandboxes_adapter.py

@@ -233,6 +233,35 @@ class SandboxesAdapter(Sandboxes):
             logger.error("Failed to list sandboxes", exc_info=e)
             raise ExceptionConverter.to_sandbox_exception(e) from e
 
+    async def patch_sandbox_metadata(
+        self, sandbox_id: str, patch: dict[str, str | None]
+    ) -> SandboxInfo:
+        """Patch metadata for a sandbox using the metadata-specific lifecycle endpoint."""
+        try:
+            from opensandbox.api.lifecycle.api.sandboxes import (
+                patch_sandboxes_sandbox_id_metadata,
+            )
+            from opensandbox.api.lifecycle.models import PatchSandboxMetadataRequest
+            from opensandbox.api.lifecycle.models import Sandbox as ApiSandbox
+
+            client = await self._get_client()
+            response_obj = await patch_sandboxes_sandbox_id_metadata.asyncio_detailed(
+                client=client,
+                sandbox_id=sandbox_id,
+                body=PatchSandboxMetadataRequest.from_dict(patch),
+            )
+
+            handle_api_error(response_obj, f"Patch sandbox {sandbox_id} metadata")
+            parsed = require_parsed(
+                response_obj,
+                ApiSandbox,
+                f"Patch sandbox {sandbox_id} metadata",
+            )
+            return SandboxModelConverter.to_sandbox_info(parsed)
+        except Exception as e:
+            logger.error("Failed to patch sandbox %s metadata", sandbox_id, exc_info=e)
+            raise ExceptionConverter.to_sandbox_exception(e) from e
+
     async def create_snapshot(
         self, sandbox_id: str, request: CreateSnapshotRequest | None = None
     ) -> SnapshotInfo:

opensandbox-0.1.9.dev0/src/opensandbox/api/diagnostic/__init__.py

@@ -0,0 +1,24 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""A client library for accessing OpenSandbox Diagnostics API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

opensandbox-0.1.9.dev0/src/opensandbox/api/diagnostic/api/diagnostics/get_sandboxes_sandbox_id_diagnostics_events.py

@@ -0,0 +1,282 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.diagnostic_content_response import DiagnosticContentResponse
+from ...models.error_response import ErrorResponse
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    scope: str,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["scope"] = scope
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/sandboxes/{sandbox_id}/diagnostics/events".format(
+            sandbox_id=quote(str(sandbox_id), safe=""),
+        ),
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> DiagnosticContentResponse | ErrorResponse | None:
+    if response.status_code == 200:
+        response_200 = DiagnosticContentResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = ErrorResponse.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = ErrorResponse.from_dict(response.json())
+
+        return response_403
+
+    if response.status_code == 404:
+        response_404 = ErrorResponse.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = ErrorResponse.from_dict(response.json())
+
+        return response_500
+
+    if response.status_code == 501:
+        response_501 = ErrorResponse.from_dict(response.json())
+
+        return response_501
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[DiagnosticContentResponse | ErrorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    scope: str,
+) -> Response[DiagnosticContentResponse | ErrorResponse]:
+    """Get diagnostic events
+
+     Retrieve a best-effort descriptor for sandbox diagnostic event text.
+
+    Events are rendered as diagnostic text rather than exposed as a stable
+    structured event model. Depending on the selected `scope` and runtime, event
+    text may include lifecycle transitions, runtime or platform events such as
+    Kubernetes Events, network diagnostic events, process activity events, or
+    other implementation-defined event material.
+
+    This endpoint does not provide streaming, pagination, or a stable line-level
+    schema in this version. The server returns a JSON descriptor for currently
+    available diagnostic event text for the requested scope, subject to
+    implementation-defined retention and response size limits. The descriptor
+    either embeds the text as `content` or returns a `contentUrl` where the
+    text can be downloaded.
+
+    Args:
+        sandbox_id (str):
+        scope (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[DiagnosticContentResponse | ErrorResponse]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        scope=scope,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    scope: str,
+) -> DiagnosticContentResponse | ErrorResponse | None:
+    """Get diagnostic events
+
+     Retrieve a best-effort descriptor for sandbox diagnostic event text.
+
+    Events are rendered as diagnostic text rather than exposed as a stable
+    structured event model. Depending on the selected `scope` and runtime, event
+    text may include lifecycle transitions, runtime or platform events such as
+    Kubernetes Events, network diagnostic events, process activity events, or
+    other implementation-defined event material.
+
+    This endpoint does not provide streaming, pagination, or a stable line-level
+    schema in this version. The server returns a JSON descriptor for currently
+    available diagnostic event text for the requested scope, subject to
+    implementation-defined retention and response size limits. The descriptor
+    either embeds the text as `content` or returns a `contentUrl` where the
+    text can be downloaded.
+
+    Args:
+        sandbox_id (str):
+        scope (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        DiagnosticContentResponse | ErrorResponse
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        scope=scope,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    scope: str,
+) -> Response[DiagnosticContentResponse | ErrorResponse]:
+    """Get diagnostic events
+
+     Retrieve a best-effort descriptor for sandbox diagnostic event text.
+
+    Events are rendered as diagnostic text rather than exposed as a stable
+    structured event model. Depending on the selected `scope` and runtime, event
+    text may include lifecycle transitions, runtime or platform events such as
+    Kubernetes Events, network diagnostic events, process activity events, or
+    other implementation-defined event material.
+
+    This endpoint does not provide streaming, pagination, or a stable line-level
+    schema in this version. The server returns a JSON descriptor for currently
+    available diagnostic event text for the requested scope, subject to
+    implementation-defined retention and response size limits. The descriptor
+    either embeds the text as `content` or returns a `contentUrl` where the
+    text can be downloaded.
+
+    Args:
+        sandbox_id (str):
+        scope (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[DiagnosticContentResponse | ErrorResponse]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        scope=scope,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    scope: str,
+) -> DiagnosticContentResponse | ErrorResponse | None:
+    """Get diagnostic events
+
+     Retrieve a best-effort descriptor for sandbox diagnostic event text.
+
+    Events are rendered as diagnostic text rather than exposed as a stable
+    structured event model. Depending on the selected `scope` and runtime, event
+    text may include lifecycle transitions, runtime or platform events such as
+    Kubernetes Events, network diagnostic events, process activity events, or
+    other implementation-defined event material.
+
+    This endpoint does not provide streaming, pagination, or a stable line-level
+    schema in this version. The server returns a JSON descriptor for currently
+    available diagnostic event text for the requested scope, subject to
+    implementation-defined retention and response size limits. The descriptor
+    either embeds the text as `content` or returns a `contentUrl` where the
+    text can be downloaded.
+
+    Args:
+        sandbox_id (str):
+        scope (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        DiagnosticContentResponse | ErrorResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            scope=scope,
+        )
+    ).parsed