scalebox-sdk 0.1.25__py3-none-any.whl → 1.0.1__py3-none-any.whl

scalebox/cli.py

@@ -1,125 +1,125 @@
-"""
-Command-line interface for ScaleBox Python SDK
-"""
-
-import argparse
-import asyncio
-import sys
-from typing import Optional
-
-from . import __version__
-from .code_interpreter import AsyncSandbox, Sandbox
-from .connection_config import ConnectionConfig
-
-
-def create_parser() -> argparse.ArgumentParser:
-    """Create the command-line argument parser."""
-    parser = argparse.ArgumentParser(
-        prog="scalebox",
-        description="ScaleBox Python SDK - Multi-language code execution sandbox",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-
-    parser.add_argument(
-        "--version",
-        action="version",
-        version=f"ScaleBox Python SDK {__version__}",
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # Sandbox command
-    sandbox_parser = subparsers.add_parser("sandbox", help="Sandbox operations")
-    sandbox_parser.add_argument(
-        "--create", action="store_true", help="Create a new sandbox"
-    )
-    sandbox_parser.add_argument("--list", action="store_true", help="List sandboxes")
-    sandbox_parser.add_argument("--destroy", help="Destroy a sandbox by ID")
-
-    # Code execution command
-    exec_parser = subparsers.add_parser("exec", help="Execute code")
-    exec_parser.add_argument("--code", required=True, help="Code to execute")
-    exec_parser.add_argument(
-        "--language", default="python", help="Programming language"
-    )
-    exec_parser.add_argument("--sandbox-id", help="Sandbox ID to use")
-    exec_parser.add_argument(
-        "--async-mode", action="store_true", help="Use async execution"
-    )
-
-    # Configuration
-    parser.add_argument("--api-key", help="API key for authentication")
-    parser.add_argument("--domain", help="API domain")
-    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-
-    return parser
-
-
-async def async_main():
-    """Async main function."""
-    parser = create_parser()
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        return
-
-    # Create connection config
-    config = ConnectionConfig(
-        api_key=args.api_key,
-        domain=args.domain,
-        debug=args.debug,
-    )
-
-    if args.command == "sandbox":
-        if args.create:
-            print("Creating sandbox...")
-            if args.async_mode:
-                sandbox = await AsyncSandbox.create()
-                print(f"Created async sandbox: {sandbox.id}")
-            else:
-                sandbox = Sandbox.create()
-                print(f"Created sandbox: {sandbox.id}")
-        elif args.list:
-            print("Listing sandboxes...")
-            # TODO: Implement sandbox listing
-            print("Sandbox listing not implemented yet")
-        elif args.destroy:
-            print(f"Destroying sandbox: {args.destroy}")
-            # TODO: Implement sandbox destruction
-            print("Sandbox destruction not implemented yet")
-
-    elif args.command == "exec":
-        print(f"Executing {args.language} code...")
-        print(f"Code: {args.code}")
-
-        if args.async_mode:
-            sandbox = await AsyncSandbox.create()
-            try:
-                result = await sandbox.run_code(args.code, language=args.language)
-                print(f"Result: {result.logs.stdout}")
-            finally:
-                await sandbox.close()
-        else:
-            sandbox = Sandbox.create()
-            try:
-                result = sandbox.run_code(args.code, language=args.language)
-                print(f"Result: {result.logs.stdout}")
-            finally:
-                sandbox.close()
-
-
-def main():
-    """Main entry point."""
-    try:
-        asyncio.run(async_main())
-    except KeyboardInterrupt:
-        print("\nOperation cancelled by user")
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+"""
+Command-line interface for ScaleBox Python SDK
+"""
+
+import argparse
+import asyncio
+import sys
+from typing import Optional
+
+from . import __version__
+from .code_interpreter import AsyncSandbox, Sandbox
+from .connection_config import ConnectionConfig
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the command-line argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="scalebox",
+        description="ScaleBox Python SDK - Multi-language code execution sandbox",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"ScaleBox Python SDK {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Sandbox command
+    sandbox_parser = subparsers.add_parser("sandbox", help="Sandbox operations")
+    sandbox_parser.add_argument(
+        "--create", action="store_true", help="Create a new sandbox"
+    )
+    sandbox_parser.add_argument("--list", action="store_true", help="List sandboxes")
+    sandbox_parser.add_argument("--destroy", help="Destroy a sandbox by ID")
+
+    # Code execution command
+    exec_parser = subparsers.add_parser("exec", help="Execute code")
+    exec_parser.add_argument("--code", required=True, help="Code to execute")
+    exec_parser.add_argument(
+        "--language", default="python", help="Programming language"
+    )
+    exec_parser.add_argument("--sandbox-id", help="Sandbox ID to use")
+    exec_parser.add_argument(
+        "--async-mode", action="store_true", help="Use async execution"
+    )
+
+    # Configuration
+    parser.add_argument("--api-key", help="API key for authentication")
+    parser.add_argument("--domain", help="API domain")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+
+    return parser
+
+
+async def async_main():
+    """Async main function."""
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    # Create connection config
+    config = ConnectionConfig(
+        api_key=args.api_key,
+        domain=args.domain,
+        debug=args.debug,
+    )
+
+    if args.command == "sandbox":
+        if args.create:
+            print("Creating sandbox...")
+            if args.async_mode:
+                sandbox = await AsyncSandbox.create()
+                print(f"Created async sandbox: {sandbox.id}")
+            else:
+                sandbox = Sandbox.create()
+                print(f"Created sandbox: {sandbox.id}")
+        elif args.list:
+            print("Listing sandboxes...")
+            # TODO: Implement sandbox listing
+            print("Sandbox listing not implemented yet")
+        elif args.destroy:
+            print(f"Destroying sandbox: {args.destroy}")
+            # TODO: Implement sandbox destruction
+            print("Sandbox destruction not implemented yet")
+
+    elif args.command == "exec":
+        print(f"Executing {args.language} code...")
+        print(f"Code: {args.code}")
+
+        if args.async_mode:
+            sandbox = await AsyncSandbox.create()
+            try:
+                result = await sandbox.run_code(args.code, language=args.language)
+                print(f"Result: {result.logs.stdout}")
+            finally:
+                await sandbox.close()
+        else:
+            sandbox = Sandbox.create()
+            try:
+                result = sandbox.run_code(args.code, language=args.language)
+                print(f"Result: {result.logs.stdout}")
+            finally:
+                sandbox.close()
+
+
+def main():
+    """Main entry point."""
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        print("\nOperation cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

scalebox/client/aclient.py

@@ -1,57 +1,57 @@
-# import sys, os
-# sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../scalebox'))
-import asyncio
-
-import aiohttp
-from generated import api_pb2
-from generated.api_pb2_connect import AsyncFilesystemClient
-
-
-async def watch_directory_example():
-    # 创建 aiohttp 客户端会话
-    async with aiohttp.ClientSession() as session:
-        # 创建文件系统客户端
-        client = AsyncFilesystemClient(
-            base_url="http://localhost:8080",
-            http_client=session,
-            # protocol=ConnectProtocol.CONNECT_PROTOBUF  # 如果需要指定协议
-        )
-
-        # 创建监视请求
-        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__), '../../scalebox'))
+import asyncio
+
+import aiohttp
+from generated import api_pb2
+from generated.api_pb2_connect import AsyncFilesystemClient
+
+
+async def watch_directory_example():
+    # 创建 aiohttp 客户端会话
+    async with aiohttp.ClientSession() as session:
+        # 创建文件系统客户端
+        client = AsyncFilesystemClient(
+            base_url="http://localhost:8080",
+            http_client=session,
+            # protocol=ConnectProtocol.CONNECT_PROTOBUF  # 如果需要指定协议
+        )
+
+        # 创建监视请求
+        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/client/client.py

@@ -1,102 +1,102 @@
-import os
-import sys
-
-from utils.httpxclient import HTTPXClient
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "generated"))
-
-import asyncio
-
-import httpx
-from generated import api_pb2
-from generated.api_pb2_connect import AsyncFilesystemClient
-
-
-# 自定义 HTTP 客户端适配器
-class CustomHTTPClient:
-    def __init__(self):
-        self.client = httpx.Client()
-
-    def request(self, method, url, headers, content, timeout, extensions):
-        # 移除可能导致问题的参数或调整调用方式
-        # 根据 ConnectRPC 的实际需求调整
-        try:
-            response = self.client.request(
-                method=method,
-                url=url,
-                headers=headers,
-                content=content,
-                timeout=timeout,
-            )
-            return response
-        except TypeError as e:
-            # 如果仍然有参数问题，尝试不同的调用方式
-            if "unexpected keyword argument" in str(e):
-                # 移除有问题的参数
-                kwargs = {
-                    "method": method,
-                    "url": url,
-                    "headers": headers,
-                    "content": content,
-                    "timeout": timeout,
-                }
-                # 移除可能引起问题的参数
-                if "body" in str(e):
-                    kwargs.pop("content", None)
-
-                response = self.client.request(**kwargs)
-                return response
-            raise
-
-
-async def main():
-    # 创建客户端
-    client = AsyncFilesystemClient(
-        base_url="http://localhost:8080", http_client=HTTPXClient
-    )
-
-    # 调用服务器流式方法
-    # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
-    #          "Keepalive-Ping-Interval":1000}
-    extra = {"Authorization": "Bearer root"}
-    # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
-    # print(resp)
-    # print(resp.entry)
-    # stream = fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"), extra_headers=extra)
-    # request = RequestType(your_field="value")
-
-    # 处理流式响应
-    async for response in client.watch_dir(
-        api_pb2.WatchDirRequest(path="/root"), extra_headers=extra
-    ):
-        print(f"Received: {response}")
-        # 处理每个响应项
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
-# print("Available protocol options:")
-# print(f"CONNECT_PROTOBUF: {ConnectProtocol.CONNECT_PROTOBUF}")
-# print(f"CONNECT_JSON: {ConnectProtocol.CONNECT_JSON}")
-# # print(f"GRPC_PROTOBUF: {ConnectProtocol.GRPC_PROTOBUF}")
-# # print(f"GRPC_JSON: {ConnectProtocol.GRPC_JSON}")
-# BASE = "http://localhost:8080"
-# # client = CustomHTTPClient()
-# fs_cli=FilesystemClient(base_url=BASE,protocol=ConnectProtocol.CONNECT_PROTOBUF)
-# # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
-# #          "Keepalive-Ping-Interval":1000}
-# extra = {"Authorization": "Bearer root"}
-# # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
-# # print(resp)
-# # print(resp.entry)
-# stream=fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"),extra_headers=extra)
-# # 3. 消费流
-# print("-------------------------")
-# for resp in stream:
-#     # resp 就是 api_pb2.WatchDirResponse
-#     print(resp)
-#
-# # 4. 检查错误（可选）
-# if stream.error():
-#     raise stream.error()
+import os
+import sys
+
+from utils.httpxclient import HTTPXClient
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "generated"))
+
+import asyncio
+
+import httpx
+from generated import api_pb2
+from generated.api_pb2_connect import AsyncFilesystemClient
+
+
+# 自定义 HTTP 客户端适配器
+class CustomHTTPClient:
+    def __init__(self):
+        self.client = httpx.Client()
+
+    def request(self, method, url, headers, content, timeout, extensions):
+        # 移除可能导致问题的参数或调整调用方式
+        # 根据 ConnectRPC 的实际需求调整
+        try:
+            response = self.client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                content=content,
+                timeout=timeout,
+            )
+            return response
+        except TypeError as e:
+            # 如果仍然有参数问题，尝试不同的调用方式
+            if "unexpected keyword argument" in str(e):
+                # 移除有问题的参数
+                kwargs = {
+                    "method": method,
+                    "url": url,
+                    "headers": headers,
+                    "content": content,
+                    "timeout": timeout,
+                }
+                # 移除可能引起问题的参数
+                if "body" in str(e):
+                    kwargs.pop("content", None)
+
+                response = self.client.request(**kwargs)
+                return response
+            raise
+
+
+async def main():
+    # 创建客户端
+    client = AsyncFilesystemClient(
+        base_url="http://localhost:8080", http_client=HTTPXClient
+    )
+
+    # 调用服务器流式方法
+    # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
+    #          "Keepalive-Ping-Interval":1000}
+    extra = {"Authorization": "Bearer root"}
+    # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
+    # print(resp)
+    # print(resp.entry)
+    # stream = fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"), extra_headers=extra)
+    # request = RequestType(your_field="value")
+
+    # 处理流式响应
+    async for response in client.watch_dir(
+        api_pb2.WatchDirRequest(path="/root"), extra_headers=extra
+    ):
+        print(f"Received: {response}")
+        # 处理每个响应项
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# print("Available protocol options:")
+# print(f"CONNECT_PROTOBUF: {ConnectProtocol.CONNECT_PROTOBUF}")
+# print(f"CONNECT_JSON: {ConnectProtocol.CONNECT_JSON}")
+# # print(f"GRPC_PROTOBUF: {ConnectProtocol.GRPC_PROTOBUF}")
+# # print(f"GRPC_JSON: {ConnectProtocol.GRPC_JSON}")
+# BASE = "http://localhost:8080"
+# # client = CustomHTTPClient()
+# fs_cli=FilesystemClient(base_url=BASE,protocol=ConnectProtocol.CONNECT_PROTOBUF)
+# # extra = {"Authorization": "Bearer root","Transfer-Encoding":"chunked",
+# #          "Keepalive-Ping-Interval":1000}
+# extra = {"Authorization": "Bearer root"}
+# # resp=fs_cli.stat(api_pb2.StatRequest(path="/root/Dockerfile"),extra_headers=extra)
+# # print(resp)
+# # print(resp.entry)
+# stream=fs_cli.watch_dir(api_pb2.WatchDirRequest(path="/root"),extra_headers=extra)
+# # 3. 消费流
+# print("-------------------------")
+# for resp in stream:
+#     # resp 就是 api_pb2.WatchDirResponse
+#     print(resp)
+#
+# # 4. 检查错误（可选）
+# if stream.error():
+#     raise stream.error()

scalebox/code_interpreter/__init__.py

@@ -1,12 +1,12 @@
-from .code_interpreter_async import AsyncSandbox
-from .code_interpreter_sync import Sandbox
-from .models import (
-    Context,
-    Execution,
-    ExecutionError,
-    Logs,
-    MIMEType,
-    OutputHandler,
-    OutputMessage,
-    Result,
-)
+from .code_interpreter_async import AsyncSandbox
+from .code_interpreter_sync import Sandbox
+from .models import (
+    Context,
+    Execution,
+    ExecutionError,
+    Logs,
+    MIMEType,
+    OutputHandler,
+    OutputMessage,
+    Result,
+)