scalebox-sdk 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

scalebox/__init__.py

@@ -9,7 +9,7 @@ A multi-language code execution sandbox with support for:
 - Real-time callbacks and monitoring
 """
 
-__version__ = "0.1.11"
+__version__ = "0.1.13"
 __author__ = "ScaleBox Team"
 __email__ = "dev@scalebox.dev"
 

scalebox/code_interpreter/code_interpreter_async.py

@@ -205,9 +205,9 @@ class AsyncSandbox(BaseAsyncSandbox):
             )
 
         # Set headers
-        headers = {
-            "Authorization": "Bearer root",
-        }
+        # headers = {
+        #     "Authorization": "Bearer root",
+        # }
 
         try:
             # Create client and execute request
@@ -227,7 +227,7 @@ class AsyncSandbox(BaseAsyncSandbox):
             # Execute request and get response stream
             responses = client.execute(
                 req=request,
-                extra_headers=headers,
+                extra_headers=self.connection_config.headers,
                 timeout_seconds=request_timeout,
             )
 
@@ -298,9 +298,9 @@ class AsyncSandbox(BaseAsyncSandbox):
                 http_client=self._session,
                 base_url=self.envd_api_url,
             )
-            headers = {
-                "Authorization": "Bearer root",
-            }
+            # headers = {
+            #     "Authorization": "Bearer root",
+            # }
 
             # Build request
             request = api_pb2.CreateContextRequest(
@@ -311,7 +311,7 @@ class AsyncSandbox(BaseAsyncSandbox):
             # Execute request and get response stream
             response = await client.create_context(
                 req=request,
-                extra_headers=headers,
+                extra_headers=self.connection_config.headers,
             )
             return Context.from_json(
                 {
@@ -361,9 +361,9 @@ class AsyncSandbox(BaseAsyncSandbox):
                 base_url=self.envd_api_url,
                 http_client=self._session,
             )
-            headers = {
-                "Authorization": "Bearer root",
-            }
-            await client.destroy_context(destroy_context_request, extra_headers=headers)
+            # headers = {
+            #     "Authorization": "Bearer root",
+            # }
+            await client.destroy_context(destroy_context_request,extra_headers=self.connection_config.headers)
         except Exception as e:
             logger.warning(f"Failed to destroy context {context.id}: {e}")

scalebox/code_interpreter/code_interpreter_sync.py

@@ -199,13 +199,13 @@ class Sandbox(BaseSandbox):
 
             # Execute code via gRPC
             execution = Execution()
-            headers = {
-                "Authorization": "Bearer root",
-            }
+            # headers = {
+            #     "Authorization": "Bearer root",
+            # }
             response_stream = client.execute(
                 execute_request,
                 timeout_seconds=deadline - time.time(),
-                extra_headers=headers,
+                extra_headers=self.connection_config.headers,
             )
 
             # Process stream responses
@@ -263,9 +263,9 @@ class Sandbox(BaseSandbox):
                 base_url=self.envd_api_url,
                 http_client=self._urllib3_pool,
             )
-            headers = {
-                "Authorization": "Bearer root",
-            }
+            # headers = {
+            #     "Authorization": "Bearer root",
+            # }
             # Create context via gRPC
             response = client.create_context(
                 create_context_request,
@@ -308,10 +308,10 @@ class Sandbox(BaseSandbox):
                 base_url=self.envd_api_url,
                 http_client=self._urllib3_pool,
             )
-            headers = {
-                "Authorization": "Bearer root",
-            }
-            client.destroy_context(destroy_context_request, extra_headers=headers)
+            # headers = {
+            #     "Authorization": "Bearer root",
+            # }
+            client.destroy_context(destroy_context_request,extra_headers=self.connection_config.headers)
 
         except Exception as e:
             logger.warning(f"Failed to destroy context {context.id}: {e}")

scalebox/generated/api_pb2_connect.py

@@ -690,7 +690,7 @@ class ProcessClient:
         extra_headers: HeaderInput | None = None,
         timeout_seconds: float | None = None,
     ) -> Iterator[api_pb2.ConnectResponse]:
-        stream_output = self.call_connect(req, extra_headers)
+        stream_output = self.call_connect(req, extra_headers,timeout_seconds)
         err = stream_output.error()
         if err is not None:
             raise err
@@ -725,7 +725,7 @@ class ProcessClient:
         extra_headers: HeaderInput | None = None,
         timeout_seconds: float | None = None,
     ) -> Iterator[api_pb2.StartResponse]:
-        stream_output = self.call_start(req, extra_headers)
+        stream_output = self.call_start(req, extra_headers,timeout_seconds)
         err = stream_output.error()
         if err is not None:
             raise err
@@ -943,7 +943,7 @@ class AsyncProcessClient:
         extra_headers: HeaderInput | None = None,
         timeout_seconds: float | None = None,
     ) -> AsyncIterator[api_pb2.StartResponse]:
-        stream_output = await self.call_start(req, extra_headers)
+        stream_output = await self.call_start(req, extra_headers,timeout_seconds)
         err = stream_output.error()
         if err is not None:
             raise err

scalebox/sandbox_sync/main.py

@@ -335,7 +335,7 @@ class Sandbox(SandboxSetup, SandboxApi):
         :param timeout: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.
         :param metadata: Custom metadata for the sandbox
         :param envs: Custom environment variables for the sandbox
-        :param api_key: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable
+        :param api_key: scalebox API Key to use for authentication, defaults to `CSX_API_KEY` environment variable
         :param request_timeout: Timeout for the request in **seconds**
         :param proxy: Proxy to use for the request and for the **requests made to the returned sandbox**
         :param secure: Envd is secured with access token and cannot be used without it

scalebox/test/aclient.py

@@ -1,72 +1,72 @@
-# import sys, os
-# sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'generated'))
-import asyncio
-
-import aiohttp
-from generated import api_pb2
-from generated.api_pb2_connect import AsyncFilesystemClient
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-
-@retry(
-    stop=stop_after_attempt(5),  # 最大重试5次
-    wait=wait_exponential(multiplier=1, min=4, max=10),  # 指数退避等待
-    retry=retry_if_exception_type(
-        (aiohttp.ClientError, asyncio.TimeoutError)
-    ),  # 针对这些异常重试
-)
-async def watch_directory_example():
-    # 创建 aiohttp 客户端会话
-    async with aiohttp.ClientSession(
-        timeout=aiohttp.ClientTimeout(total=None)
-    ) as session:
-        # 创建文件系统客户端
-        client = AsyncFilesystemClient(
-            base_url="http://localhost:8080",
-            http_client=session,
-            # protocol=ConnectProtocol.CONNECT_PROTOBUF  # 如果需要指定协议
-        )
-        # extra = {"authorization": "Bearer root"}
-        # 创建监视请求
-        request = api_pb2.WatchDirRequest(path="/root")
-
-        # 可选：添加额外的请求头
-        extra_headers = {
-            "Authorization": "Bearer root",
-            "X-Custom-Header": "custom-value",
-        }
-
-        try:
-            # 使用 async for 循环处理流式响应
-            async for response in client.watch_dir(
-                request, extra_headers=extra_headers
-            ):
-                print(f"Received event: {response}")
-                # 在这里处理每个事件
-                # 例如，根据事件类型执行不同的操作
-
-                # 如果收到特定事件，可以中断循环
-                # if response.event_type == api_pb2.WatchDirResponse.EVENT_TYPE_STOP:
-                #     break
-
-        except Exception as e:
-            print(f"Error during directory watching: {e}")
-
-        finally:
-            # 关闭会话（在 with 语句中会自动关闭，但这里为了清晰展示）
-            await session.close()
-
-
-async def main():
-    # 运行监视示例
-    await watch_directory_example()
-
-
-if __name__ == "__main__":
-    # 运行异步主函数
-    asyncio.run(main())
+# import sys, os
+# sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'generated'))
+import asyncio
+
+import aiohttp
+from generated import api_pb2
+from generated.api_pb2_connect import AsyncFilesystemClient
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+@retry(
+    stop=stop_after_attempt(5),  # 最大重试5次
+    wait=wait_exponential(multiplier=1, min=4, max=10),  # 指数退避等待
+    retry=retry_if_exception_type(
+        (aiohttp.ClientError, asyncio.TimeoutError)
+    ),  # 针对这些异常重试
+)
+async def watch_directory_example():
+    # 创建 aiohttp 客户端会话
+    async with aiohttp.ClientSession(
+        timeout=aiohttp.ClientTimeout(total=None)
+    ) as session:
+        # 创建文件系统客户端
+        client = AsyncFilesystemClient(
+            base_url="http://localhost:8080",
+            http_client=session,
+            # protocol=ConnectProtocol.CONNECT_PROTOBUF  # 如果需要指定协议
+        )
+        # extra = {"authorization": "Bearer root"}
+        # 创建监视请求
+        request = api_pb2.WatchDirRequest(path="/root")
+
+        # 可选：添加额外的请求头
+        extra_headers = {
+            "Authorization": "Bearer root",
+            "X-Custom-Header": "custom-value",
+        }
+
+        try:
+            # 使用 async for 循环处理流式响应
+            async for response in client.watch_dir(
+                request, extra_headers=extra_headers
+            ):
+                print(f"Received event: {response}")
+                # 在这里处理每个事件
+                # 例如，根据事件类型执行不同的操作
+
+                # 如果收到特定事件，可以中断循环
+                # if response.event_type == api_pb2.WatchDirResponse.EVENT_TYPE_STOP:
+                #     break
+
+        except Exception as e:
+            print(f"Error during directory watching: {e}")
+
+        finally:
+            # 关闭会话（在 with 语句中会自动关闭，但这里为了清晰展示）
+            await session.close()
+
+
+async def main():
+    # 运行监视示例
+    await watch_directory_example()
+
+
+if __name__ == "__main__":
+    # 运行异步主函数
+    asyncio.run(main())

scalebox/test/code_interpreter_centext.py

@@ -1,21 +1,21 @@
-import asyncio
-import time
-
-from scalebox.code_interpreter import AsyncSandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-async def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-async def main():
-    sandbox = AsyncSandbox()
-    context = await sandbox.create_code_context(language="python3")
-    print(context.__dict__)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
+import asyncio
+import time
+
+from scalebox.code_interpreter import AsyncSandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+async def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+async def main():
+    sandbox = AsyncSandbox()
+    context = await sandbox.create_code_context(language="python3")
+    print(context.__dict__)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scalebox/test/code_interpreter_centext_sync.py

@@ -1,21 +1,21 @@
-import asyncio
-import time
-
-from scalebox.code_interpreter import Sandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-async def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-def main():
-    sandbox = Sandbox()
-    context = sandbox.create_code_context(language="python3")
-    print(context.__dict__)
-
-
-if __name__ == "__main__":
-    main()
+import asyncio
+import time
+
+from scalebox.code_interpreter import Sandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+async def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+def main():
+    sandbox = Sandbox()
+    context = sandbox.create_code_context(language="python3")
+    print(context.__dict__)
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/code_interpreter_test.py

@@ -1,34 +1,34 @@
-import asyncio
-import time
-
-from scalebox.code_interpreter import AsyncSandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-async def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-async def main():
-    sandbox = AsyncSandbox.create()
-    proc = await sandbox.run_code(
-        """
-import time
-for i in range(3):
-    print("Hello E2B", i)
-    time.sleep(50)
-""",
-        language="python3",
-        request_timeout=3600,
-        on_stdout=pty_output_handler,
-        on_stderr=pty_output_handler,
-        on_result=pty_output_handler,
-    )
-    print(proc)
-    time.sleep(10)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
+import asyncio
+import time
+
+from scalebox.code_interpreter import AsyncSandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+async def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+async def main():
+    sandbox = AsyncSandbox.create()
+    proc = await sandbox.run_code(
+        """
+import time
+for i in range(3):
+    print("Hello E2B", i)
+    time.sleep(50)
+""",
+        language="python3",
+        request_timeout=3600,
+        on_stdout=pty_output_handler,
+        on_stderr=pty_output_handler,
+        on_result=pty_output_handler,
+    )
+    print(proc)
+    time.sleep(10)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scalebox/test/code_interpreter_test_sync.py

@@ -1,34 +1,34 @@
-import asyncio
-import time
-
-from code_interpreter import Sandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-def main():
-    sandbox = Sandbox()
-    proc = sandbox.run_code(
-        """
-import time
-for i in range(3):
-    print("Hello E2B", i)
-    time.sleep(50)
-""",
-        language="python3",
-        request_timeout=3600,
-        on_stdout=pty_output_handler,
-        on_stderr=pty_output_handler,
-        on_result=pty_output_handler,
-    )
-    print(proc)
-    time.sleep(10)
-
-
-if __name__ == "__main__":
-    main()
+import asyncio
+import time
+
+from code_interpreter import Sandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+def main():
+    sandbox = Sandbox()
+    proc = sandbox.run_code(
+        """
+import time
+for i in range(3):
+    print("Hello E2B", i)
+    time.sleep(50)
+""",
+        language="python3",
+        request_timeout=3600,
+        on_stdout=pty_output_handler,
+        on_stderr=pty_output_handler,
+        on_result=pty_output_handler,
+    )
+    print(proc)
+    time.sleep(10)
+
+
+if __name__ == "__main__":
+    main()