opensandbox-code-interpreter 0.1.0__py3-none-any.whl

code_interpreter/__init__.py

@@ -0,0 +1,45 @@
+#
+# Copyright 2025 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.
+#
+"""
+OpenSandbox Code Interpreter SDK.
+
+This package provides secure, isolated code execution capabilities built on top
+of the OpenSandbox infrastructure. It supports multiple programming languages,
+session management, and variable persistence across executions.
+"""
+
+from code_interpreter.code_interpreter import CodeInterpreter
+from code_interpreter.models.code import (
+    CodeContext,
+    SupportedLanguage,
+)
+from code_interpreter.sync.code_interpreter import CodeInterpreterSync
+
+__all__ = [
+    "CodeInterpreter",
+    "CodeInterpreterSync",
+    "CodeContext",
+    "SupportedLanguage",
+]
+
+try:
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _pkg_version
+
+    __version__ = _pkg_version("opensandbox-code-interpreter")
+except PackageNotFoundError:  # pragma: no cover
+    # Fallback for editable/uninstalled source checkouts.
+    __version__ = "0.0.0"

code_interpreter/adapters/__init__.py

@@ -0,0 +1,30 @@
+#
+# Copyright 2025 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.
+#
+"""
+Adapter implementations for code execution services.
+"""
+
+from code_interpreter.adapters.code_adapter import CodesAdapter
+from code_interpreter.adapters.converter.code_execution_converter import (
+    CodeExecutionConverter,
+)
+from code_interpreter.adapters.factory import AdapterFactory
+
+__all__ = [
+    "CodesAdapter",
+    "CodeExecutionConverter",
+    "AdapterFactory",
+]

code_interpreter/adapters/code_adapter.py

@@ -0,0 +1,268 @@
+#
+# Copyright 2025 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.
+#
+"""
+Adapter implementation for code execution service.
+
+Provides the concrete implementation of Codes by wrapping auto-generated
+API clients and handling SSE streaming for real-time code execution.
+"""
+
+import json
+import logging
+
+import httpx
+from opensandbox.adapters.converter.event_node import EventNode
+from opensandbox.adapters.converter.exception_converter import (
+    ExceptionConverter,
+)
+from opensandbox.adapters.converter.execution_event_dispatcher import (
+    ExecutionEventDispatcher,
+)
+from opensandbox.adapters.converter.response_handler import (
+    handle_api_error,
+    require_parsed,
+)
+from opensandbox.config import ConnectionConfig
+from opensandbox.exceptions import InvalidArgumentException, SandboxApiException
+from opensandbox.models.execd import Execution, ExecutionHandlers
+from opensandbox.models.sandboxes import SandboxEndpoint
+
+from code_interpreter.adapters.converter.code_execution_converter import (
+    CodeExecutionConverter,
+)
+from code_interpreter.models.code import CodeContext, SupportedLanguage
+from code_interpreter.services.code import Codes
+
+logger = logging.getLogger(__name__)
+
+
+class CodesAdapter(Codes):
+    """
+    Adapter implementation for code execution service.
+
+    This adapter wraps auto-generated API clients and provides the concrete
+    implementation of the Codes interface. It handles both standard
+    API calls and SSE streaming for real-time code execution output.
+
+    Similar to CommandServiceAdapter, this adapter uses:
+    - Generated API clients for simple operations (create_context, interrupt)
+    - Direct httpx SSE streaming for run
+    - ExceptionConverter for unified exception handling
+    """
+
+    RUN_CODE_PATH = "/code"
+    CREATE_CONTEXT_PATH = "/code/context"
+
+    def __init__(
+        self, execd_endpoint: SandboxEndpoint, connection_config: ConnectionConfig
+    ) -> None:
+        """
+        Initialize the code service adapter.
+
+        Args:
+            execd_endpoint: Endpoint for execd daemon connection
+            connection_config: Shared connection configuration (transport, headers, timeouts)
+        """
+        self.execd_endpoint = execd_endpoint
+        self.connection_config = connection_config
+        from opensandbox.api.execd import Client
+
+        protocol = self.connection_config.protocol
+        base_url = f"{protocol}://{self.execd_endpoint.endpoint}"
+        timeout_seconds = self.connection_config.request_timeout.total_seconds()
+        timeout = httpx.Timeout(timeout_seconds)
+
+        headers = {
+            "User-Agent": self.connection_config.user_agent,
+            **self.connection_config.headers,
+        }
+
+        # Execd API does not require authentication
+        self._client = Client(
+            base_url=base_url,
+            timeout=timeout,
+        )
+
+        # Inject httpx client (adapter-owned)
+        self._httpx_client = httpx.AsyncClient(
+            base_url=base_url,
+            headers=headers,
+            timeout=timeout,
+            transport=self.connection_config.transport,
+        )
+        self._client.set_async_httpx_client(self._httpx_client)
+
+        # SSE client (read timeout disabled)
+        sse_headers = {
+            **headers,
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+        }
+        self._sse_client = httpx.AsyncClient(
+            headers=sse_headers,
+            timeout=httpx.Timeout(
+                connect=timeout_seconds,
+                read=None,
+                write=timeout_seconds,
+                pool=None,
+            ),
+            transport=self.connection_config.transport,
+        )
+
+    async def _get_client(self):
+        """Return the client for execd API (no auth required)."""
+        return self._client
+
+    def _get_execd_url(self, path: str) -> str:
+        """Build URL for execd endpoint."""
+        protocol = self.connection_config.protocol
+        return f"{protocol}://{self.execd_endpoint.endpoint}{path}"
+
+    async def _get_sse_client(self) -> httpx.AsyncClient:
+        """Return SSE client (read timeout disabled) for execd streaming."""
+        return self._sse_client
+
+    async def create_context(self, language: str) -> CodeContext:
+        """
+        Creates a new execution context for code interpretation.
+
+        Uses the generated API client for this non-streaming operation.
+        """
+        try:
+            from opensandbox.api.execd.api.code_interpreting import create_code_context
+            from opensandbox.api.execd.models.code_context_request import (
+                CodeContextRequest,
+            )
+
+            client = await self._get_client()
+            api_request = CodeContextRequest(language=language)
+
+            response_obj = await create_code_context.asyncio_detailed(
+                client=client,
+                body=api_request,
+            )
+
+            handle_api_error(response_obj, "Create code context")
+            from opensandbox.api.execd.models.code_context import (
+                CodeContext as ApiCodeContext,
+            )
+
+            parsed = require_parsed(response_obj, ApiCodeContext, "Create code context")
+            return CodeExecutionConverter.from_api_code_context(parsed)
+
+        except Exception as e:
+            logger.error("Failed to create context", exc_info=e)
+            raise ExceptionConverter.to_sandbox_exception(e) from e
+
+    async def run(
+        self,
+        code: str,
+        *,
+        context: CodeContext | None = None,
+        handlers: ExecutionHandlers | None = None,
+    ) -> Execution:
+        """
+        Executes code within the specified context using SSE streaming.
+
+        Similar to CommandServiceAdapter.run, this uses direct httpx
+        streaming to handle SSE responses from the execd service.
+        """
+        if not code.strip():
+            raise InvalidArgumentException("Code cannot be empty")
+
+        try:
+            # Default context: ephemeral python context (server-side behavior)
+            context = context or CodeContext(language=SupportedLanguage.PYTHON)
+            api_request = CodeExecutionConverter.to_api_run_code_request(code, context)
+
+            # Prepare URL
+            url = self._get_execd_url(self.RUN_CODE_PATH)
+
+            execution = Execution(
+                id=None,
+                execution_count=None,
+                result=[],
+                error=None,
+            )
+
+            # Use SSE client for streaming responses (read timeout disabled)
+            client = await self._get_sse_client()
+
+            # Use streaming request for SSE
+            async with client.stream("POST", url, json=api_request) as response:
+                if response.status_code != 200:
+                    await response.aread()
+                    error_body = response.text
+                    logger.error(
+                        "Failed to run code. Status: %s, Body: %s",
+                        response.status_code,
+                        error_body,
+                    )
+                    raise SandboxApiException(
+                        message=f"Failed to run code. Status code: {response.status_code}",
+                        status_code=response.status_code,
+                    )
+
+                dispatcher = ExecutionEventDispatcher(execution, handlers)
+
+                async for line in response.aiter_lines():
+                    if not line.strip():
+                        continue
+
+                    # Handle potential SSE format "data: ..."
+                    data = line
+                    if data.startswith("data:"):
+                        data = data[5:].strip()
+
+                    try:
+                        event_dict = json.loads(data)
+                        event_node = EventNode(**event_dict)
+                        await dispatcher.dispatch(event_node)
+                    except json.JSONDecodeError:
+                        logger.debug("Failed to parse SSE line: %s", line)
+                        continue
+                    except Exception as e:
+                        logger.error("Error processing event: %s", data, exc_info=e)
+                        continue
+
+            return execution
+
+        except Exception as e:
+            logger.error(
+                "Failed to run code (length: %s)", len(code), exc_info=e
+            )
+            raise ExceptionConverter.to_sandbox_exception(e) from e
+
+    async def interrupt(self, execution_id: str) -> None:
+        """
+        Interrupts a currently running code execution.
+
+        Uses the generated API client for this operation.
+        """
+        try:
+            from opensandbox.api.execd.api.code_interpreting import interrupt_code
+
+            client = await self._get_client()
+            response_obj = await interrupt_code.asyncio_detailed(
+                client=client,
+                id=execution_id,
+            )
+
+            handle_api_error(response_obj, "Interrupt code execution")
+
+        except Exception as e:
+            logger.error("Failed to interrupt code execution", exc_info=e)
+            raise ExceptionConverter.to_sandbox_exception(e) from e

code_interpreter/adapters/converter/__init__.py

@@ -0,0 +1,26 @@
+#
+# Copyright 2025 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.
+#
+"""
+Model converters for code execution adapters.
+"""
+
+from code_interpreter.adapters.converter.code_execution_converter import (
+    CodeExecutionConverter,
+)
+
+__all__ = [
+    "CodeExecutionConverter",
+]

code_interpreter/adapters/converter/code_execution_converter.py

@@ -0,0 +1,108 @@
+#
+# Copyright 2025 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.
+#
+"""
+Converter for code execution models between domain and API layers.
+
+Handles the transformation of code execution requests and contexts
+between the domain model and auto-generated API client models.
+"""
+
+from typing import Any
+
+from opensandbox.api.execd.models import CodeContext as ApiCodeContext
+
+from code_interpreter.models.code import CodeContext
+
+
+class CodeExecutionConverter:
+    """
+    Converts code execution models between domain and API representations.
+    """
+
+    @staticmethod
+    def to_api_run_code_request(code: str, context: CodeContext | None) -> dict[str, Any]:
+        """
+        Converts domain code + context to API request dictionary.
+
+        Args:
+            code: Source code to execute
+            context: Optional execution context (language + optional id)
+
+        Returns:
+            Dictionary representation for API call
+        """
+        result: dict[str, Any] = {"code": code}
+
+        if context is not None:
+            result["context"] = CodeExecutionConverter.to_api_code_context(context)
+
+        return result
+
+    @staticmethod
+    def to_api_code_context(context: CodeContext) -> dict[str, Any]:
+        """
+        Converts domain CodeContext to API context dictionary.
+
+        Args:
+            context: Domain model code context
+
+        Returns:
+            Dictionary representation for API call
+        """
+        result: dict[str, Any] = {
+            "language": context.language,
+        }
+
+        if context.id:
+            result["id"] = context.id
+
+        return result
+
+    @staticmethod
+    def from_api_code_context(api_context: ApiCodeContext) -> CodeContext:
+        """
+        Converts API CodeContextResponse to domain CodeContext.
+
+        Args:
+            api_context: API response from create_code_context
+
+        Returns:
+            Domain model code context
+        """
+        from opensandbox.api.execd.types import UNSET
+
+        context_id = api_context.id if api_context.id is not UNSET else None
+
+        return CodeContext(
+            id=context_id,
+            language=api_context.language
+        )
+
+    @staticmethod
+    def from_api_code_context_dict(api_context: dict[str, Any]) -> CodeContext:
+        """
+        Converts API code context dictionary to domain CodeContext.
+
+        Args:
+            api_context: API response dictionary containing context data
+
+        Returns:
+            Domain model code context
+        """
+        return CodeContext(
+            id=api_context.get("id"),
+            language=api_context.get("language", "python")
+        )

code_interpreter/adapters/factory.py

@@ -0,0 +1,58 @@
+#
+# Copyright 2025 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.
+#
+"""
+Factory for creating code interpreter services.
+
+Provides a centralized way to create and configure code execution services
+with proper dependency injection and configuration management.
+"""
+
+from opensandbox.config import ConnectionConfig
+from opensandbox.models.sandboxes import SandboxEndpoint
+
+from code_interpreter.adapters.code_adapter import CodesAdapter
+from code_interpreter.services.code import Codes
+
+
+class AdapterFactory:
+    """
+    Factory for creating code interpreter service instances.
+
+    This factory handles the creation of code execution services with proper
+    configuration and dependency injection, ensuring all services have access
+    to the required HTTP client and endpoint configuration.
+    """
+
+    def __init__(self, connection_config: ConnectionConfig) -> None:
+        """
+        Initialize the factory with shared connection configuration.
+
+        Args:
+            connection_config: Shared connection configuration (transport, headers, timeouts)
+        """
+        self.connection_config = connection_config
+
+    def create_code_execution_service(self, endpoint: SandboxEndpoint) -> Codes:
+        """
+        Create a code execution service for the specified endpoint.
+
+        Args:
+            endpoint: Sandbox endpoint for code execution services.
+
+        Returns:
+            Configured code service instance.
+        """
+        return CodesAdapter(endpoint, self.connection_config)