opensandbox-code-interpreter 1.1.0__tar.gz → 1.1.1__tar.gz

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opensandbox-code-interpreter
-Version: 1.1.0
+Version: 1.1.1
 Summary: OpenSandbox Code Interpreter Python SDK - Advanced code execution with persistent contexts
 Project-URL: Homepage, https://open-sandbox.ai
 Project-URL: Repository, https://github.com/opensandbox-group/OpenSandbox
@@ -223,7 +223,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: opensandbox<2.0.0,>=1.1.0
+Requires-Dist: opensandbox<2.0.0,>=1.1.1
 Requires-Dist: pydantic<3.0,>=2.4.2
 Description-Content-Type: text/markdown
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/pyproject.toml

@@ -43,7 +43,7 @@ classifiers = [
 ]
 dependencies = [
     "pydantic>=2.4.2,<3.0",
-    "opensandbox>=1.1.0,<2.0.0",
+    "opensandbox>=1.1.1,<2.0.0",
 ]
 
 [project.urls]

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/adapters/code_adapter.py

@@ -72,14 +72,8 @@ 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
+    Handles standard API calls plus direct httpx SSE streaming for
+    real-time code execution output.
     """
 
     RUN_CODE_PATH = "/code"
@@ -104,11 +98,7 @@ class CodesAdapter(Codes):
         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,
-            **self.execd_endpoint.headers,
-        }
+        headers = self.execd_endpoint.build_request_headers(self.connection_config)
 
         # Execd API does not require authentication
         self._client = Client(
@@ -116,12 +106,19 @@ class CodesAdapter(Codes):
             timeout=timeout,
         )
 
-        # Inject httpx client (adapter-owned)
+        # Adapter clients must own their transports: aclose() closes them,
+        # and the shared/user connection_config transport must survive that.
+        self._owns_clients = self.connection_config.owns_transport
+        main_transport: httpx.AsyncBaseTransport | None
+        if self._owns_clients:
+            main_transport = self.connection_config.new_owned_transport()
+        else:
+            main_transport = self.connection_config.transport
         self._httpx_client = httpx.AsyncClient(
             base_url=base_url,
             headers=headers,
             timeout=timeout,
-            transport=self.connection_config.transport,
+            transport=main_transport,
         )
         self._client.set_async_httpx_client(self._httpx_client)
 
@@ -134,6 +131,11 @@ class CodesAdapter(Codes):
         # SSE bootstraps bypass the retry wrapper: request bodies are
         # not replayable and a non-idempotent status opt-in would cause
         # duplicate execution on a resent SSE POST.
+        sse_transport = (
+            self.connection_config.new_owned_transport()
+            if self._owns_clients
+            else self.connection_config.transport
+        )
         self._sse_client = httpx.AsyncClient(
             headers=sse_headers,
             timeout=httpx.Timeout(
@@ -142,7 +144,7 @@ class CodesAdapter(Codes):
                 write=timeout_seconds,
                 pool=None,
             ),
-            transport=unwrap_retry_transport(self.connection_config.transport),
+            transport=unwrap_retry_transport(sse_transport),
         )
 
     async def _get_client(self):
@@ -158,6 +160,21 @@ class CodesAdapter(Codes):
         """Return SSE client (read timeout disabled) for execd streaming."""
         return self._sse_client
 
+    async def aclose(self) -> None:
+        """Release the adapter-owned HTTP clients.
+
+        Never closes the shared ``connection_config.transport``; the sandbox
+        stays usable after ``aclose()``. Clients wrapping a user-supplied
+        transport are left open (httpx would close the caller's transport
+        with them).
+        """
+        if not self._owns_clients:
+            return
+        try:
+            await self._httpx_client.aclose()
+        finally:
+            await self._sse_client.aclose()
+
     async def create_context(self, language: str) -> CodeContext:
         """
         Creates a new execution context for code interpretation.
@@ -268,7 +285,7 @@ class CodesAdapter(Codes):
         """
         Executes code within the specified context using SSE streaming.
 
-        Similar to CommandServiceAdapter.run, this uses direct httpx
+        Uses direct httpx
         streaming to handle SSE responses from the execd service.
         """
         if not code.strip():

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/code_interpreter.py

@@ -22,6 +22,7 @@ support, session management, and variable persistence.
 """
 
 import asyncio
+import contextlib
 import logging
 import time
 from datetime import timedelta
@@ -64,7 +65,7 @@ class CodeInterpreter:
 
     Key Features:
 
-    - Multi-language Code Execution: Support for Python, JavaScript, Bash, Java, Kotlin
+    - Multi-language Code Execution: Python, JavaScript, TypeScript, Go, Bash
     - Session Management: Persistent execution contexts with variable state
     - Sandbox Integration: Full access to underlying sandbox file system and command execution
     - Streaming Execution: Real-time code execution with output streaming
@@ -73,11 +74,12 @@ class CodeInterpreter:
     Usage Example:
 
     ```python
-    # First create a sandbox instance
-
+    # The sandbox must use the opensandbox/code-interpreter image (or a
+    # derivative); the strict health check requires the Jupyter runtime.
     sandbox = await Sandbox.create(
-        "python:3.11",
-        resource={"cpu": "1", "memory": "2Gi"}
+        "opensandbox/code-interpreter:latest",
+        entrypoint=["/opt/code-interpreter/code-interpreter.sh"],
+        resource={"cpu": "1", "memory": "2Gi"},
     )
 
     # Then create a code interpreter wrapping the sandbox
@@ -87,9 +89,10 @@ class CodeInterpreter:
     from code_interpreter.models.code import SupportedLanguage
     context = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
     result = await interpreter.codes.run("print('Hello World')", context=context)
-    print(result.logs.stdout)  # Output: Hello World
+    print(result.text)  # Output: Hello World
 
     # Access underlying sandbox for file operations
+    from opensandbox.models.filesystem import WriteEntry
     await interpreter.sandbox.files.write_files([
         WriteEntry(path="data.txt", data="Hello")
     ])
@@ -98,10 +101,16 @@ class CodeInterpreter:
         context=context,
     )
 
-    # Always clean up resources
+    # Clean up: closing the interpreter releases its HTTP clients; the
+    # underlying sandbox lifecycle stays caller-owned.
+    await interpreter.aclose()
     await sandbox.kill()
     await sandbox.close()
     ```
+
+    CodeInterpreter also supports the async context-manager protocol; exiting
+    the ``async with`` block releases the interpreter's HTTP clients (not the
+    sandbox).
     """
 
     def __init__(self, sandbox: Sandbox, code_service: Codes) -> None:
@@ -161,6 +170,24 @@ class CodeInterpreter:
         """
         return self._sandbox.commands
 
+    async def aclose(self) -> None:
+        """
+        Release resources owned by the code interpreter.
+
+        Closes the HTTP clients used by the code execution service. The
+        underlying sandbox is NOT affected; manage its lifecycle separately
+        (``sandbox.kill()`` / ``sandbox.close()``). Safe to call multiple times.
+        """
+        aclose = getattr(self._code_service, "aclose", None)
+        if aclose is not None:
+            await aclose()
+
+    async def __aenter__(self) -> "CodeInterpreter":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.aclose()
+
     @property
     def metrics(self):
         """
@@ -335,9 +362,16 @@ class CodeInterpreter:
             )
 
             interpreter = cls(sandbox, code_execution_service)
-
-            if not skip_health_check:
-                await interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            try:
+                if not skip_health_check:
+                    await interpreter.check_ready(
+                        ready_timeout, health_check_polling_interval
+                    )
+            except Exception:
+                # Don't leak the service's clients on a failed creation.
+                with contextlib.suppress(Exception):
+                    await interpreter.aclose()
+                raise
 
             logger.info(f"Code interpreter {sandbox.id} created successfully")
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/models/code_sync.py

@@ -27,6 +27,7 @@ class SupportedLanguageSync:
     GO = "go"
     TYPESCRIPT = "typescript"
     BASH = "bash"
+    JAVASCRIPT = "javascript"
 
 
 class CodeContextSync(BaseModel):

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/services/code.py

@@ -38,10 +38,10 @@ class Codes(Protocol):
     Supported Languages:
 
     - Python: Full Python 3.x support with package management
-    - JavaScript/Node.js: ES6+ with npm package support
+    - JavaScript: ES6+ with npm package support
+    - TypeScript
+    - Go
     - Bash: Shell scripting with full system access
-    - Java: Compilation and execution with classpath management
-    - Kotlin: Script and compiled Kotlin execution
 
     Key Features:
 

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/sync/adapters/code_adapter.py

@@ -99,18 +99,22 @@ class CodesAdapterSync(CodesSync):
         base_url = f"{self.connection_config.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,
-            **(self.execd_endpoint.headers or {}),
-        }
-
+        headers = self.execd_endpoint.build_request_headers(self.connection_config)
+
+        # Adapter clients must own their transports: close() closes them,
+        # and the shared/user connection_config transport must survive that.
+        self._owns_clients = self.connection_config.owns_transport
+        main_transport: httpx.BaseTransport | None
+        if self._owns_clients:
+            main_transport = self.connection_config.new_owned_transport()
+        else:
+            main_transport = self.connection_config.transport
         self._client = Client(base_url=base_url, timeout=timeout)
         self._httpx_client = httpx.Client(
             base_url=base_url,
             headers=headers,
             timeout=timeout,
-            transport=self.connection_config.transport,
+            transport=main_transport,
         )
         self._client.set_httpx_client(self._httpx_client)
 
@@ -122,12 +126,17 @@ class CodesAdapterSync(CodesSync):
         # SSE bootstraps bypass the retry wrapper: request bodies are
         # not replayable and a non-idempotent status opt-in would cause
         # duplicate execution on a resent SSE POST.
+        sse_transport = (
+            self.connection_config.new_owned_transport()
+            if self._owns_clients
+            else self.connection_config.transport
+        )
         self._sse_client = httpx.Client(
             headers=sse_headers,
             timeout=httpx.Timeout(
                 connect=timeout_seconds, read=None, write=timeout_seconds, pool=None
             ),
-            transport=unwrap_retry_transport(self.connection_config.transport),
+            transport=unwrap_retry_transport(sse_transport),
         )
 
     def _get_execd_url(self, path: str) -> str:
@@ -136,6 +145,21 @@ class CodesAdapterSync(CodesSync):
             f"{self.connection_config.protocol}://{self.execd_endpoint.endpoint}{path}"
         )
 
+    def close(self) -> None:
+        """Release the adapter-owned HTTP clients.
+
+        Never closes the shared ``connection_config.transport``; the sandbox
+        stays usable after ``close()``. Clients wrapping a user-supplied
+        transport are left open (httpx would close the caller's transport
+        with them).
+        """
+        if not self._owns_clients:
+            return
+        try:
+            self._httpx_client.close()
+        finally:
+            self._sse_client.close()
+
     def create_context(self, language: str) -> CodeContextSync:
         """
         Create a new execution context for code interpretation (sync).

{opensandbox_code_interpreter-1.1.0 → opensandbox_code_interpreter-1.1.1}/src/code_interpreter/sync/code_interpreter.py

@@ -17,6 +17,7 @@
 Synchronous Code Interpreter SDK.
 """
 
+import contextlib
 import logging
 import time
 from datetime import timedelta
@@ -73,14 +74,18 @@ class CodeInterpreterSync:
     ```python
     from opensandbox.sync.sandbox import SandboxSync
     from code_interpreter.sync.code_interpreter import CodeInterpreterSync
-    from code_interpreter.models.code import SupportedLanguage
+    from code_interpreter.models.code_sync import SupportedLanguageSync
 
-    sandbox = SandboxSync.create("python:3.11")
+    sandbox = SandboxSync.create(
+        "opensandbox/code-interpreter:latest",
+        entrypoint=["/opt/code-interpreter/code-interpreter.sh"],
+    )
     interpreter = CodeInterpreterSync.create(sandbox=sandbox)
 
-    ctx = interpreter.codes.create_context(SupportedLanguage.PYTHON)
+    ctx = interpreter.codes.create_context(SupportedLanguageSync.PYTHON)
     result = interpreter.codes.run("print('hi')", context=ctx)
 
+    interpreter.close()
     sandbox.kill()
     sandbox.close()
     ```
@@ -139,6 +144,24 @@ class CodeInterpreterSync:
         """
         return self._sandbox.commands
 
+    def close(self) -> None:
+        """
+        Release resources owned by the code interpreter.
+
+        Closes the HTTP clients used by the code execution service. The
+        underlying sandbox is NOT affected; manage its lifecycle separately
+        (``sandbox.kill()`` / ``sandbox.close()``). Safe to call multiple times.
+        """
+        close = getattr(self._code_service, "close", None)
+        if close is not None:
+            close()
+
+    def __enter__(self) -> "CodeInterpreterSync":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
     @property
     def metrics(self):
         """
@@ -289,9 +312,14 @@ class CodeInterpreterSync:
             code_service = factory.create_code_execution_service(endpoint)
 
             interpreter = cls(sandbox, code_service)
-
-            if not skip_health_check:
-                interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            try:
+                if not skip_health_check:
+                    interpreter.check_ready(ready_timeout, health_check_polling_interval)
+            except Exception:
+                # Don't leak the service's clients on a failed creation.
+                with contextlib.suppress(Exception):
+                    interpreter.close()
+                raise
 
             logger.info(f"Code interpreter {sandbox.id} created successfully")
             return interpreter