agentrun-inner-test 0.0.46__py3-none-any.whl

agentrun/sandbox/__sandbox_async_template.py

@@ -0,0 +1,463 @@
+"""Sandbox 高层 API / Sandbox High-Level API
+
+此模块定义沙箱资源的高级API。
+This module defines the high-level API for sandbox resources.
+"""
+
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    overload,
+    TYPE_CHECKING,
+    Union,
+)
+
+from agentrun.sandbox.model import TemplateType
+from agentrun.utils.config import Config
+from agentrun.utils.model import BaseModel
+
+if TYPE_CHECKING:
+    from agentrun.sandbox.aio_sandbox import AioSandbox
+    from agentrun.sandbox.browser_sandbox import BrowserSandbox
+    from agentrun.sandbox.code_interpreter_sandbox import CodeInterpreterSandbox
+    from agentrun.sandbox.model import (
+        ListSandboxesInput,
+        ListSandboxesOutput,
+        NASConfig,
+        OSSMountConfig,
+        PageableInput,
+        PolarFsConfig,
+        TemplateInput,
+    )
+    from agentrun.sandbox.template import Template
+
+
+class Sandbox(BaseModel):
+    """Sandbox 实例
+
+    封装了 Sandbox 的基本信息和操作方法
+    """
+
+    _template_type: Optional[TemplateType]
+
+    created_at: Optional[str] = None
+    """沙箱创建时间 / Sandbox creation time"""
+    ended_at: Optional[str] = None
+    """沙箱结束时间 / Sandbox end time"""
+    last_updated_at: Optional[str] = None
+    """最后更新时间 / Last updated time"""
+    metadata: Optional[Dict[str, Any]] = None
+    """元数据 / Metadata"""
+    sandbox_arn: Optional[str] = None
+    """沙箱全局唯一资源名称 / Sandbox ARN"""
+    sandbox_id: Optional[str] = None
+    """沙箱 ID / Sandbox ID"""
+    sandbox_idle_ttlin_seconds: Optional[int] = None
+    """沙箱空闲 TTL（秒） / Sandbox Idle TTL (seconds)"""
+    sandbox_idle_timeout_seconds: Optional[int] = None
+    """沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)"""
+    status: Optional[str] = None
+    """沙箱状态 / Sandbox status"""
+    template_id: Optional[str] = None
+    """模板 ID / Template ID"""
+    template_name: Optional[str] = None
+    """模板名称 / Template name"""
+    _config: Optional[Config] = None
+    """配置对象，用于子类的 data_api 初始化 / Config object for data_api initialization"""
+
+    @classmethod
+    def __get_client(cls):
+        """获取 Sandbox 客户端"""
+        from .client import SandboxClient
+
+        return SandboxClient()
+
+    @classmethod
+    @overload
+    async def create_async(
+        cls,
+        template_type: Literal[TemplateType.CODE_INTERPRETER],
+        template_name: Optional[str] = None,
+        sandbox_idle_timeout_seconds: Optional[int] = 600,
+        nas_config: Optional["NASConfig"] = None,
+        oss_mount_config: Optional["OSSMountConfig"] = None,
+        polar_fs_config: Optional["PolarFsConfig"] = None,
+        config: Optional[Config] = None,
+    ) -> "CodeInterpreterSandbox":
+        ...
+
+    @classmethod
+    @overload
+    async def create_async(
+        cls,
+        template_type: Literal[TemplateType.BROWSER],
+        template_name: Optional[str] = None,
+        sandbox_idle_timeout_seconds: Optional[int] = 600,
+        nas_config: Optional["NASConfig"] = None,
+        oss_mount_config: Optional["OSSMountConfig"] = None,
+        polar_fs_config: Optional["PolarFsConfig"] = None,
+        config: Optional[Config] = None,
+    ) -> "BrowserSandbox":
+        ...
+
+    @classmethod
+    @overload
+    async def create_async(
+        cls,
+        template_type: Literal[TemplateType.AIO],
+        template_name: Optional[str] = None,
+        sandbox_idle_timeout_seconds: Optional[int] = 600,
+        nas_config: Optional["NASConfig"] = None,
+        oss_mount_config: Optional["OSSMountConfig"] = None,
+        polar_fs_config: Optional["PolarFsConfig"] = None,
+        config: Optional[Config] = None,
+    ) -> "AioSandbox":
+        ...
+
+    @classmethod
+    async def create_async(
+        cls,
+        template_type: TemplateType,
+        template_name: Optional[str] = None,
+        sandbox_idle_timeout_seconds: Optional[int] = 600,
+        nas_config: Optional["NASConfig"] = None,
+        oss_mount_config: Optional["OSSMountConfig"] = None,
+        polar_fs_config: Optional["PolarFsConfig"] = None,
+        config: Optional[Config] = None,
+    ) -> Union["CodeInterpreterSandbox", "BrowserSandbox", "AioSandbox"]:
+
+        if template_name is None:
+            # todo 可以考虑为用户创建一个模板？
+            raise ValueError("template_name is required")
+
+        # 先根据传入的template_name，获取template的类型
+        template = await cls.get_template_async(template_name, config=config)
+
+        # 根据 template 类型创建相应的 Sandbox 子类
+        from agentrun.sandbox.aio_sandbox import AioSandbox
+        from agentrun.sandbox.browser_sandbox import BrowserSandbox
+        from agentrun.sandbox.code_interpreter_sandbox import (
+            CodeInterpreterSandbox,
+        )
+
+        if template_type != template.template_type:
+            raise ValueError(
+                f"template_type of {template_name} is {template.template_type},"
+                f" not {template_type}"
+            )
+
+        # 创建 Sandbox（返回基类实例）
+        base_sandbox = await cls.__get_client().create_sandbox_async(
+            template_name=template_name,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            nas_config=nas_config,
+            oss_mount_config=oss_mount_config,
+            polar_fs_config=polar_fs_config,
+        )
+
+        # 根据 template 类型转换为对应的子类实例
+        sandbox = None
+        if template.template_type == TemplateType.CODE_INTERPRETER:
+            sandbox = CodeInterpreterSandbox.model_validate(
+                base_sandbox.model_dump(by_alias=False)
+            )
+        elif template.template_type == TemplateType.BROWSER:
+            sandbox = BrowserSandbox.model_validate(
+                base_sandbox.model_dump(by_alias=False)
+            )
+        elif template.template_type == TemplateType.AIO:
+            sandbox = AioSandbox.model_validate(
+                base_sandbox.model_dump(by_alias=False)
+            )
+        else:
+            raise ValueError(
+                f"template_type {template.template_type} is not supported"
+            )
+
+        sandbox._config = config
+        return sandbox
+
+    @classmethod
+    async def stop_by_id_async(cls, sandbox_id: str):
+        """通过 ID 停止 Sandbox（异步）
+
+        Args:
+            sandbox_id: Sandbox ID
+            config: 配置对象
+
+        Returns:
+            Sandbox: Sandbox 对象
+        """
+        if sandbox_id is None:
+            raise ValueError("sandbox_id is required")
+        # todo 后续适配后使用 stop()
+        return await cls.__get_client().delete_sandbox_async(sandbox_id)
+
+    @classmethod
+    async def delete_by_id_async(cls, sandbox_id: str):
+        """通过 ID 删除 Sandbox（异步）
+
+        Args:
+            sandbox_id: Sandbox ID
+            config: 配置对象
+
+        Returns:
+            Sandbox: Sandbox 对象
+        """
+        if sandbox_id is None:
+            raise ValueError("sandbox_id is required")
+        return await cls.__get_client().delete_sandbox_async(sandbox_id)
+
+    @classmethod
+    async def list_async(
+        cls,
+        input: Optional["ListSandboxesInput"] = None,
+        config: Optional[Config] = None,
+    ) -> "ListSandboxesOutput":
+        """列出 Sandboxes（异步）
+
+        Args:
+            input: 列表查询配置
+            config: 配置对象
+
+        Returns:
+            ListSandboxesOutput: Sandbox 列表结果
+        """
+        return await cls.__get_client().list_sandboxes_async(input, config)
+
+    @classmethod
+    @overload
+    async def connect_async(
+        cls,
+        sandbox_id: str,
+        template_type: Literal[TemplateType.CODE_INTERPRETER],
+        config: Optional[Config] = None,
+    ) -> "CodeInterpreterSandbox":
+        ...
+
+    @classmethod
+    @overload
+    async def connect_async(
+        cls,
+        sandbox_id: str,
+        template_type: Literal[TemplateType.BROWSER],
+        config: Optional[Config] = None,
+    ) -> "BrowserSandbox":
+        ...
+
+    @classmethod
+    @overload
+    async def connect_async(
+        cls,
+        sandbox_id: str,
+        template_type: Literal[TemplateType.AIO],
+        config: Optional[Config] = None,
+    ) -> "AioSandbox":
+        ...
+
+    @classmethod
+    @overload
+    async def connect_async(
+        cls,
+        sandbox_id: str,
+        template_type: None = None,
+        config: Optional[Config] = None,
+    ) -> Union["CodeInterpreterSandbox", "BrowserSandbox", "AioSandbox"]:
+        ...
+
+    @classmethod
+    async def connect_async(
+        cls,
+        sandbox_id: str,
+        template_type: Optional[TemplateType] = None,
+        config: Optional[Config] = None,
+    ) -> Union["CodeInterpreterSandbox", "BrowserSandbox", "AioSandbox"]:
+        """连接一个SandBox（异步）
+
+        Args:
+            sandbox_id: Sandbox ID
+            type: 可选的类型参数，用于类型提示和运行时验证
+            config: 配置对象
+
+        Returns:
+            Sandbox: 根据模板类型返回对应的 Sandbox 子类对象
+
+        Raises:
+            ValueError: 如果模板类型不支持或与预期类型不匹配
+        """
+        if sandbox_id is None:
+            raise ValueError("sandbox_id is required")
+
+        # 先获取 sandbox 信息
+        sandbox = await cls.__get_client().get_sandbox_async(
+            sandbox_id, config=config
+        )
+
+        # 根据 template_name 获取 template 类型
+        if sandbox.template_name is None:
+            raise ValueError(f"Sandbox {sandbox_id} has no template_name")
+
+        template = await cls.get_template_async(
+            sandbox.template_name, config=config
+        )
+
+        # 如果提供了 type 参数，验证类型是否匹配
+        if (
+            template_type is not None
+            and template.template_type != template_type
+        ):
+            raise ValueError(
+                f"Sandbox {sandbox_id} has template type"
+                f" {template.template_type}, but expected {template_type}"
+            )
+
+        # 根据 template 类型创建相应的 Sandbox 子类
+        from agentrun.sandbox.aio_sandbox import AioSandbox
+        from agentrun.sandbox.browser_sandbox import BrowserSandbox
+        from agentrun.sandbox.code_interpreter_sandbox import (
+            CodeInterpreterSandbox,
+        )
+
+        result = None
+        if template.template_type == TemplateType.CODE_INTERPRETER:
+            result = CodeInterpreterSandbox.model_validate(
+                sandbox.model_dump(by_alias=False)
+            )
+        elif template.template_type == TemplateType.BROWSER:
+            result = BrowserSandbox.model_validate(
+                sandbox.model_dump(by_alias=False)
+            )
+        elif template.template_type == TemplateType.AIO:
+            result = AioSandbox.model_validate(
+                sandbox.model_dump(by_alias=False)
+            )
+        else:
+            raise ValueError(
+                f"Unsupported template type: {template.template_type}. "
+                "Expected 'code-interpreter', 'browser' or 'aio'"
+            )
+
+        result._config = config
+        return result
+
+    # ==================== Template 相关类方法 ====================
+
+    @classmethod
+    async def create_template_async(
+        cls, input: "TemplateInput", config: Optional[Config] = None
+    ) -> "Template":
+        """创建 Template（异步）
+
+        Args:
+            input: Template 配置
+            config: 配置对象
+
+        Returns:
+            Template: 创建的 Template 对象
+        """
+        if input.template_type is None:
+            raise ValueError("template_type is required")
+        return await cls.__get_client().create_template_async(
+            input, config=config
+        )
+
+    @classmethod
+    async def get_template_async(
+        cls, template_name: str, config: Optional[Config] = None
+    ) -> "Template":
+        """获取 Template（异步）
+
+        Args:
+            template_name: Template 名称
+            config: 配置对象
+
+        Returns:
+            Template: Template 对象
+        """
+        if template_name is None:
+            raise ValueError("template_name is required")
+        return await cls.__get_client().get_template_async(
+            template_name, config=config
+        )
+
+    @classmethod
+    async def update_template_async(
+        cls,
+        template_name: str,
+        input: "TemplateInput",
+        config: Optional[Config] = None,
+    ) -> "Template":
+        """更新 Template（异步）
+
+        Args:
+            template_name: Template 名称
+            input: Template 更新配置
+            config: 配置对象
+
+        Returns:
+            Template: 更新后的 Template 对象
+        """
+        if template_name is None:
+            raise ValueError("template_name is required")
+        return await cls.__get_client().update_template_async(
+            template_name, input, config=config
+        )
+
+    @classmethod
+    async def delete_template_async(
+        cls, template_name: str, config: Optional[Config] = None
+    ) -> "Template":
+        """删除 Template（异步）
+
+        Args:
+            template_name: Template 名称
+            config: 配置对象
+
+        Returns:
+            Template: 删除的 Template 对象
+        """
+        if template_name is None:
+            raise ValueError("template_name is required")
+        return await cls.__get_client().delete_template_async(
+            template_name, config=config
+        )
+
+    @classmethod
+    async def list_templates_async(
+        cls,
+        input: Optional["PageableInput"] = None,
+        config: Optional[Config] = None,
+    ) -> List["Template"]:
+        """列出 Templates（异步）
+
+        Args:
+            input: 分页配置
+            config: 配置对象
+
+        Returns:
+            List[Template]: Template 列表
+        """
+        return await cls.__get_client().list_templates_async(
+            input, config=config
+        )
+
+    async def get_async(self):
+        if self.sandbox_id is None:
+            raise ValueError("sandbox_id is required to get a Sandbox")
+
+        return await self.connect_async(self.sandbox_id)
+
+    async def delete_async(self):
+        if self.sandbox_id is None:
+            raise ValueError("sandbox_id is required to delete a Sandbox")
+
+        return await self.delete_by_id_async(self.sandbox_id)
+
+    async def stop_async(self):
+        if self.sandbox_id is None:
+            raise ValueError("sandbox_id is required to stop a Sandbox")
+        # todo 后续适配后使用 stop()
+        return await self.delete_by_id_async(self.sandbox_id)

agentrun/sandbox/__template_async_template.py

@@ -0,0 +1,152 @@
+"""Template 高层 API / Template High-Level API
+
+此模块定义沙箱模板资源的高级API。
+This module defines the high-level API for sandbox template resources.
+"""
+
+from typing import Dict, List, Optional
+
+from agentrun.sandbox.model import (
+    PageableInput,
+    TemplateContainerConfiguration,
+    TemplateCredentialConfiguration,
+    TemplateInput,
+    TemplateLogConfiguration,
+    TemplateMcpOptions,
+    TemplateMcpState,
+    TemplateNetworkConfiguration,
+    TemplateOssConfiguration,
+    TemplateType,
+)
+from agentrun.utils.config import Config
+from agentrun.utils.model import BaseModel
+
+
+class Template(BaseModel):
+    """Template 实例
+
+    封装了 Template 的基本信息和操作方法
+    """
+
+    template_id: Optional[str] = None
+    """模板 ID / Template ID"""
+    template_name: Optional[str] = None
+    """模板名称 / Template Name"""
+    template_version: Optional[str] = None
+    """模板版本 / Template Version"""
+    template_arn: Optional[str] = None
+    """模板 ARN / Template ARN"""
+    resource_name: Optional[str] = None
+    """资源名称 / Resource Name"""
+    template_type: Optional[TemplateType] = None
+    """模板类型 / Template Type"""
+    cpu: Optional[float] = None
+    """CPU 核数 / CPU Cores"""
+    memory: Optional[int] = None
+    """内存大小（MB） / Memory Size (MB)"""
+    disk_size: Optional[int] = None
+    """磁盘大小（GB） / Disk Size (GB)"""
+    description: Optional[str] = None
+    """描述 / Description"""
+    execution_role_arn: Optional[str] = None
+    """执行角色 ARN / Execution Role ARN"""
+    sandbox_idle_timeout_in_seconds: Optional[int] = None
+    """沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)"""
+    sandbox_ttlin_seconds: Optional[int] = None
+    """沙箱存活时间（秒） / Sandbox TTL (seconds)"""
+    share_concurrency_limit_per_sandbox: Optional[int] = None
+    """每个沙箱的最大并发会话数 / Max Concurrency Limit Per Sandbox"""
+    template_configuration: Optional[Dict] = None
+    """模板配置 / Template Configuration"""
+    environment_variables: Optional[Dict] = None
+    """环境变量 / Environment Variables"""
+    network_configuration: Optional[TemplateNetworkConfiguration] = None
+    """网络配置 / Network Configuration"""
+    oss_configuration: Optional[List[TemplateOssConfiguration]] = None
+    """OSS 配置列表 / OSS Configuration List"""
+    log_configuration: Optional[TemplateLogConfiguration] = None
+    """日志配置 / Log Configuration"""
+    credential_configuration: Optional[TemplateCredentialConfiguration] = None
+    """凭证配置 / Credential Configuration"""
+    container_configuration: Optional[TemplateContainerConfiguration] = None
+    """容器配置 / Container Configuration"""
+    mcp_options: Optional[TemplateMcpOptions] = None
+    """MCP 选项 / MCP Options"""
+    mcp_state: Optional[TemplateMcpState] = None
+    """MCP 状态 / MCP State"""
+    allow_anonymous_manage: Optional[bool] = None
+    """是否允许匿名管理 / Whether to allow anonymous management"""
+    created_at: Optional[str] = None
+    """创建时间 / Creation Time"""
+    last_updated_at: Optional[str] = None
+    """最后更新时间 / Last Updated Time"""
+    status: Optional[str] = None
+    """状态 / Status"""
+    status_reason: Optional[str] = None
+    """状态原因 / Status Reason"""
+
+    @classmethod
+    def __get_client(cls, config: Optional[Config] = None):
+        """获取 Sandbox 客户端"""
+        from .client import SandboxClient
+
+        return SandboxClient(config)
+
+    @classmethod
+    async def create_async(
+        cls, input: TemplateInput, config: Optional[Config] = None
+    ):
+        return await cls.__get_client(config=config).create_template_async(
+            input, config=config
+        )
+
+    @classmethod
+    async def delete_by_name_async(
+        cls, template_name: str, config: Optional[Config] = None
+    ):
+        return await cls.__get_client(config=config).delete_template_async(
+            template_name=template_name, config=config
+        )
+
+    @classmethod
+    async def update_by_name_async(
+        cls,
+        template_name: str,
+        input: TemplateInput,
+        config: Optional[Config] = None,
+    ):
+        return await cls.__get_client(config=config).update_template_async(
+            template_name=template_name, input=input, config=config
+        )
+
+    @classmethod
+    async def get_by_name_async(
+        cls, template_name: str, config: Optional[Config] = None
+    ):
+        return await cls.__get_client(config=config).get_template_async(
+            template_name=template_name, config=config
+        )
+
+    @classmethod
+    async def list_templates_async(
+        cls,
+        input: Optional[PageableInput] = None,
+        config: Optional[Config] = None,
+    ):
+        return await cls.__get_client(config=config).list_templates_async(
+            input, config=config
+        )
+
+    async def create_sandbox_async(
+        self,
+        sandbox_idle_timeout_seconds: Optional[int] = None,
+        config: Optional[Config] = None,
+    ):
+        if self.template_name is None:
+            raise ValueError("Template name is required")
+
+        return await self.__get_client(config=config).create_sandbox_async(
+            self.template_name,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            config=config,
+        )