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

code_interpreter/sync/services/code.py

@@ -0,0 +1,122 @@
+#
+# 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.
+#
+"""
+Synchronous code execution service interface.
+
+Defines the contract for multi-language code interpretation with context management,
+session persistence, and real-time execution capabilities (SSE streaming), **in blocking form**.
+
+This is the sync counterpart of :mod:`code_interpreter.services.code`.
+"""
+
+from typing import Protocol
+
+from opensandbox.models.execd import Execution
+from opensandbox.models.execd_sync import ExecutionHandlersSync
+
+from code_interpreter.models.code_sync import CodeContextSync
+
+
+class CodesSync(Protocol):
+    """
+    Code execution service for multi-language code interpretation (sync).
+
+    This service provides advanced code execution capabilities with context management,
+    session persistence, and multi-language support.
+
+    Supported Languages (typical):
+        - Python
+        - JavaScript / TypeScript
+        - Bash
+        - Java
+        - Kotlin (depending on server image)
+
+    Key Features:
+        - Execution Contexts: Isolated environments with persistent state
+        - Variable Persistence: Variables and imports persist across executions in a context
+        - Real-time Interruption: Stop long-running code execution safely
+        - Output Streaming: Real-time stdout/stderr via SSE
+
+    Notes:
+        - All methods are **blocking** and executed in the current thread.
+        - For non-blocking usage, prefer the async :class:`code_interpreter.services.code.Codes`.
+    """
+
+    def create_context(self, language: str) -> CodeContextSync:
+        """
+        Create a new execution context for code interpretation (blocking).
+
+        An execution context maintains state (variables/imports/working directory) across
+        multiple code executions, enabling interactive sessions.
+
+        Args:
+            language: The programming language for this context (e.g., "python", "typescript").
+
+        Returns:
+            A new CodeContextSync.
+
+        Raises:
+            SandboxException: If the language is not supported or context creation fails.
+        """
+        ...
+
+    def run(
+        self,
+        code: str,
+        *,
+        context: CodeContextSync | None = None,
+        handlers: ExecutionHandlersSync | None = None,
+    ) -> Execution:
+        """
+        Execute code within the specified context (blocking).
+
+        This method runs the provided code string in the language interpreter, capturing output,
+        errors, and execution metadata. Execution happens within the context's environment,
+        preserving variable state and working directory.
+
+        Execution behavior:
+            - Blocking: The call does not return until the stream finishes.
+            - Stateful: Variables and imports persist in the context.
+            - Streaming: Output is processed incrementally as SSE events arrive.
+            - Interruptible: Can be stopped using :meth:`interrupt`.
+
+        Args:
+            code: Source code to execute.
+            context: Execution context (language + optional id). If None, a temporary Python context is used.
+            handlers: Optional streaming handlers for stdout/stderr/events.
+
+        Returns:
+            Execution with stdout/stderr/events and execution metadata.
+
+        Raises:
+            SandboxException: If execution fails or times out.
+        """
+        ...
+
+    def interrupt(self, execution_id: str) -> None:
+        """
+        Interrupt a currently running code execution.
+
+        This method attempts to safely terminate a running execution, cleaning up resources and
+        keeping the interpreter in a consistent state.
+
+        Args:
+            execution_id: The unique identifier of the execution to interrupt.
+
+        Raises:
+            SandboxException: If interruption fails.
+        """
+        ...

opensandbox_code_interpreter-0.1.0.dist-info/METADATA

@@ -0,0 +1,462 @@
+Metadata-Version: 2.4
+Name: opensandbox-code-interpreter
+Version: 0.1.0
+Summary: OpenSandbox Code Interpreter Python SDK - Advanced code execution with persistent contexts
+Project-URL: Homepage, https://github.com/alibaba/OpenSandbox
+Project-URL: Repository, https://github.com/alibaba/OpenSandbox
+Project-URL: Documentation, https://docs.opensandbox.io
+Project-URL: Issues, https://github.com/alibaba/OpenSandbox/issues
+Author-email: OpenSandbox Team <ninan.nn@alibaba-inc.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           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.
+License-File: LICENSE
+Keywords: code-execution,code-interpreter,opensandbox,sandbox,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: opensandbox<0.2.0,>=0.1.0.dev0
+Requires-Dist: pydantic<3.0,>=2.0.0
+Description-Content-Type: text/markdown
+
+# Alibaba Code Interpreter SDK for Python
+
+English | [中文](README_zh.md)
+
+A Python SDK for executing code in secure, isolated sandboxes. It provides a high-level API for running Python, Java,
+Go, TypeScript, and other languages safely, with support for code execution contexts.
+
+## Prerequisites
+
+This SDK requires a Docker image containing the Code Interpreter runtime environment. You must use the
+`opensandbox/code-interpreter` image (or a derivative) which includes pre-installed runtimes for Python, Java, Go,
+Node.js, etc.
+
+For detailed information about supported languages and versions, refer to the
+[Environment Documentation](../../../sandboxes/code-interpreter/README.md).
+
+## Installation
+
+### pip
+
+```bash
+pip install opensandbox-code-interpreter
+```
+
+### uv
+
+```bash
+uv add opensandbox-code-interpreter
+```
+
+## Quick Start
+
+The following example demonstrates how to create a sandbox with a specific runtime configuration and execute a simple
+script.
+
+```python
+import asyncio
+from datetime import timedelta
+
+from code_interpreter import CodeInterpreter, SupportedLanguage
+from opensandbox import Sandbox
+from opensandbox.config import ConnectionConfig
+
+
+async def main() -> None:
+    # 1. Configure connection
+    config = ConnectionConfig(
+        domain="api.opensandbox.dev",
+        api_key="your-api-key",
+        request_timeout=timedelta(seconds=60),
+    )
+
+    # 2. Create a Sandbox with the code-interpreter image + runtime versions
+    sandbox = await Sandbox.create(
+        "opensandbox/code-interpreter:latest",
+        connection_config=config,
+        entrypoint=["/opt/opensandbox/code-interpreter.sh"],
+        env={
+            "PYTHON_VERSION": "3.11",
+            "JAVA_VERSION": "17",
+            "NODE_VERSION": "20",
+            "GO_VERSION": "1.24",
+        },
+    )
+
+    # 3. Use async context manager to ensure local resources are cleaned up
+    async with sandbox:
+        # 4. Create CodeInterpreter wrapper
+        interpreter = await CodeInterpreter.create(sandbox=sandbox)
+
+        # 5. Create an execution context (Python)
+        context = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
+
+        # 6. Run code
+        result = await interpreter.codes.run(
+            "import sys\nprint(sys.version)\nresult = 2 + 2\nresult",
+            context=context,
+        )
+
+        # 7. Print output
+        if result.result:
+            print(result.result[0].text)
+
+        # 8. Cleanup remote instance (optional but recommended)
+        await interpreter.kill()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Synchronous Quick Start
+
+If you prefer a synchronous API, use `SandboxSync` + `CodeInterpreterSync`:
+
+```python
+from datetime import timedelta
+
+import httpx
+from code_interpreter import CodeInterpreterSync
+from opensandbox import SandboxSync
+from opensandbox.config import ConnectionConfigSync
+
+config = ConnectionConfigSync(
+    domain="api.opensandbox.dev",
+    api_key="your-api-key",
+    request_timeout=timedelta(seconds=60),
+    transport=httpx.HTTPTransport(limits=httpx.Limits(max_connections=20)),
+)
+
+sandbox = SandboxSync.create(
+    "opensandbox/code-interpreter:latest",
+    connection_config=config,
+    entrypoint=["/opt/opensandbox/code-interpreter.sh"],
+    env={"PYTHON_VERSION": "3.11"},
+)
+with sandbox:
+    interpreter = CodeInterpreterSync.create(sandbox=sandbox)
+    result = interpreter.codes.run("result = 2 + 2\nresult")
+    if result.result:
+        print(result.result[0].text)
+    interpreter.kill()
+```
+
+## Runtime Configuration
+
+### Docker Image
+
+The Code Interpreter SDK relies on a specialized environment. Ensure your sandbox provider has the
+`opensandbox/code-interpreter` image available.
+
+### Language Version Selection
+
+You can specify the desired version of a programming language by setting the corresponding environment variable when
+creating the `Sandbox`.
+
+| Language | Environment Variable | Example Value | Default (if unset) |
+| -------- | -------------------- | ------------- | ------------------ |
+| Python   | `PYTHON_VERSION`     | `3.11`        | Image default      |
+| Java     | `JAVA_VERSION`       | `17`          | Image default      |
+| Node.js  | `NODE_VERSION`       | `20`          | Image default      |
+| Go       | `GO_VERSION`         | `1.24`        | Image default      |
+
+## Usage Examples
+
+### 1. Java Code Execution
+
+```python
+from code_interpreter import SupportedLanguage
+
+ctx = await interpreter.codes.create_context(SupportedLanguage.JAVA)
+execution = await interpreter.codes.run(
+    (
+        'System.out.println("Calculating sum...");\n'
+        + "int a = 10;\n"
+        + "int b = 20;\n"
+        + "int sum = a + b;\n"
+        + 'System.out.println("Sum: " + sum);\n'
+        + "sum"
+    ),
+    context=ctx,
+)
+
+print(execution.id)
+for msg in execution.logs.stdout:
+    print(msg.text)
+```
+
+### 2. Python with State Persistence
+
+Variables defined in one execution are available in subsequent executions within the same context.
+
+```python
+from code_interpreter import SupportedLanguage
+
+ctx = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
+
+await interpreter.codes.run(
+    "users = ['Alice', 'Bob', 'Charlie']\nprint(len(users))",
+    context=ctx,
+)
+
+result = await interpreter.codes.run(
+    "users.append('Dave')\nprint(users)\nresult = users\nresult",
+    context=ctx,
+)
+```
+
+### 3. Streaming Output Handling
+
+Handle stdout/stderr and execution events in real-time.
+
+```python
+from opensandbox.models.execd import ExecutionHandlers
+from code_interpreter import SupportedLanguage
+
+async def on_stdout(msg):
+    print("STDOUT:", msg.text)
+
+async def on_stderr(msg):
+    print("STDERR:", msg.text)
+
+handlers = ExecutionHandlers(on_stdout=on_stdout, on_stderr=on_stderr)
+
+ctx = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
+await interpreter.codes.run(
+    "import time\nfor i in range(5):\n    print(i)\n    time.sleep(0.5)",
+    context=ctx,
+    handlers=handlers,
+)
+```
+
+### 4. Multi-Language Context Isolation
+
+Different languages run in isolated environments.
+
+```python
+from code_interpreter import SupportedLanguage
+
+py_ctx = await interpreter.codes.create_context(SupportedLanguage.PYTHON)
+go_ctx = await interpreter.codes.create_context(SupportedLanguage.GO)
+
+await interpreter.codes.run("print('Running in Python')", context=py_ctx)
+await interpreter.codes.run(
+    "package main\nfunc main() { println(\"Running in Go\") }",
+    context=go_ctx,
+)
+```
+
+## Notes
+
+- **Lifecycle**: `CodeInterpreter` wraps an existing `Sandbox` instance and reuses its connection configuration.
+- **Asyncio/event loop**: avoid sharing long-lived clients across multiple event loops (e.g. pytest-asyncio defaults).

opensandbox_code_interpreter-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+code_interpreter/__init__.py,sha256=Q8aUmnJ4T74YAWbGM6h59x0BVtj1iqecI1BFT5cmIDY,1506
+code_interpreter/code_interpreter.py,sha256=UxFlURpMipCIU22WcCPINioF6HVTXqYGzfJF2iVx-Fw,11535
+code_interpreter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+code_interpreter/adapters/__init__.py,sha256=d9_KAYGoHRAtc3_SpYqeRODDQuyO3YVrB2MCRYqorUs,973
+code_interpreter/adapters/code_adapter.py,sha256=WaXu6RMFzCUrwitPGhKEt_yOEzbTX_dpKKdfeZy8hPg,9696
+code_interpreter/adapters/factory.py,sha256=mMStbY7S5iuh4pyazcpUm1gg-jK0ILDK6pjbPLcD0QQ,2032
+code_interpreter/adapters/converter/__init__.py,sha256=MdbzAZ8qvY5K02-3sQUSTqvDZC6mz3FCy3WlJoZMrM4,799
+code_interpreter/adapters/converter/code_execution_converter.py,sha256=nQb85LNhtlooK9u7k_OrMyanHAsibB97f45rkM-hRJc,3163
+code_interpreter/models/__init__.py,sha256=eF43XlKHaGJZs7m-71kOTUOiqs4AQi_695mh-nbzuOc,798
+code_interpreter/models/code.py,sha256=2OhfSBHDXITw7_oHreBKF0goQhkSk0zfNZxhH0c3-Yo,2266
+code_interpreter/models/code_sync.py,sha256=OzassgOsS5QoDA8Z4lus4RxMAL7NfpZ-Yghfk5uigX8,1270
+code_interpreter/services/__init__.py,sha256=1TzXeUf0kiV7FUfnGqtQZNJtR8IssNHCRkonEvQ3mb4,728
+code_interpreter/services/code.py,sha256=_2ppNEBPaOWpdF_UH9RanjXqFWxIxzma3pzL8odyCi0,5272
+code_interpreter/sync/__init__.py,sha256=Hvi_XtzwuFNjpAYuAKw_deui0vgsI39zGaVwv6FKeNo,700
+code_interpreter/sync/code_interpreter.py,sha256=mldsKfAVz7WXCyWudWj5pBKGhsGVatDrwHS-J_yh3IQ,9105
+code_interpreter/sync/adapters/__init__.py,sha256=weUsTURxRkUCCIXF-3wGBkFQNzY6Fs5QJybr85gQDoc,871
+code_interpreter/sync/adapters/code_adapter.py,sha256=UbXdJwhfSwv2BHY0Ur4P2cIK2D35c6Qz1g6ztN_LlaA,8837
+code_interpreter/sync/adapters/factory.py,sha256=7sNQvDxxMo38Pt-Dk4vM4fJOd9xeTJXekSzBr9B-UrQ,1909
+code_interpreter/sync/services/__init__.py,sha256=2ATCxyKIkvKCCxxA8vlozya7N0kzKh5_0XTyA1MyEaY,973
+code_interpreter/sync/services/code.py,sha256=LRjSwk_0GzJb1aAvUjI-dFsyNadbAb7Ikqp_eN2LlHM,4361
+opensandbox_code_interpreter-0.1.0.dist-info/METADATA,sha256=N71LTU6nl1hnFWjxbqOnCoRsnGUodxVX1jNCAsz5kh8,20973
+opensandbox_code_interpreter-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+opensandbox_code_interpreter-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opensandbox_code_interpreter-0.1.0.dist-info/RECORD,,

opensandbox_code_interpreter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any