wehub-resource-sync
225 lines
8.2 KiB
Python
Generated
225 lines
8.2 KiB
Python
Generated
from collections.abc import Mapping
|
|
from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
|
|
|
|
from attrs import define as _attrs_define
|
|
from attrs import field as _attrs_field
|
|
|
|
from ..types import UNSET, Unset
|
|
|
|
if TYPE_CHECKING:
|
|
from ..models.mcp_type_0 import McpType0
|
|
from ..models.sandbox_auto_resume_config import SandboxAutoResumeConfig
|
|
from ..models.sandbox_network_config import SandboxNetworkConfig
|
|
from ..models.sandbox_volume_mount import SandboxVolumeMount
|
|
|
|
|
|
T = TypeVar("T", bound="NewSandbox")
|
|
|
|
|
|
@_attrs_define
|
|
class NewSandbox:
|
|
"""
|
|
Attributes:
|
|
template_id (str): Identifier of the required template
|
|
allow_internet_access (Union[Unset, bool]): Allow sandbox to access the internet. When set to false, it behaves
|
|
the same as specifying denyOut to 0.0.0.0/0 in the network config.
|
|
auto_pause (Union[Unset, bool]): Automatically pauses the sandbox after the timeout Default: False.
|
|
auto_pause_memory (Union[Unset, bool]): Controls the snapshot kind taken when the sandbox auto-pauses on timeout
|
|
(only relevant when autoPause is true). When false, the auto-pause drops the in-memory state and persists only
|
|
the filesystem (a filesystem-only snapshot); resuming it cold-boots (reboots) the sandbox from disk. Such a
|
|
snapshot cannot be auto-resumed by traffic and must be resumed explicitly, so it cannot be combined with
|
|
autoResume. Defaults to true (full memory snapshot). Default: True.
|
|
auto_resume (Union[Unset, SandboxAutoResumeConfig]): Auto-resume configuration for paused sandboxes.
|
|
env_vars (Union[Unset, Any]):
|
|
mcp (Union['McpType0', None, Unset]): MCP configuration for the sandbox
|
|
metadata (Union[Unset, Any]):
|
|
network (Union[Unset, SandboxNetworkConfig]):
|
|
secure (Union[Unset, bool]): Secure all system communication with sandbox
|
|
timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
|
|
volume_mounts (Union[Unset, list['SandboxVolumeMount']]):
|
|
"""
|
|
|
|
template_id: str
|
|
allow_internet_access: Union[Unset, bool] = UNSET
|
|
auto_pause: Union[Unset, bool] = False
|
|
auto_pause_memory: Union[Unset, bool] = True
|
|
auto_resume: Union[Unset, "SandboxAutoResumeConfig"] = UNSET
|
|
env_vars: Union[Unset, Any] = UNSET
|
|
mcp: Union["McpType0", None, Unset] = UNSET
|
|
metadata: Union[Unset, Any] = UNSET
|
|
network: Union[Unset, "SandboxNetworkConfig"] = UNSET
|
|
secure: Union[Unset, bool] = UNSET
|
|
timeout: Union[Unset, int] = 15
|
|
volume_mounts: Union[Unset, list["SandboxVolumeMount"]] = UNSET
|
|
additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> dict[str, Any]:
|
|
from ..models.mcp_type_0 import McpType0
|
|
|
|
template_id = self.template_id
|
|
|
|
allow_internet_access = self.allow_internet_access
|
|
|
|
auto_pause = self.auto_pause
|
|
|
|
auto_pause_memory = self.auto_pause_memory
|
|
|
|
auto_resume: Union[Unset, dict[str, Any]] = UNSET
|
|
if not isinstance(self.auto_resume, Unset):
|
|
auto_resume = self.auto_resume.to_dict()
|
|
|
|
env_vars = self.env_vars
|
|
|
|
mcp: Union[None, Unset, dict[str, Any]]
|
|
if isinstance(self.mcp, Unset):
|
|
mcp = UNSET
|
|
elif isinstance(self.mcp, McpType0):
|
|
mcp = self.mcp.to_dict()
|
|
else:
|
|
mcp = self.mcp
|
|
|
|
metadata = self.metadata
|
|
|
|
network: Union[Unset, dict[str, Any]] = UNSET
|
|
if not isinstance(self.network, Unset):
|
|
network = self.network.to_dict()
|
|
|
|
secure = self.secure
|
|
|
|
timeout = self.timeout
|
|
|
|
volume_mounts: Union[Unset, list[dict[str, Any]]] = UNSET
|
|
if not isinstance(self.volume_mounts, Unset):
|
|
volume_mounts = []
|
|
for volume_mounts_item_data in self.volume_mounts:
|
|
volume_mounts_item = volume_mounts_item_data.to_dict()
|
|
volume_mounts.append(volume_mounts_item)
|
|
|
|
field_dict: dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update(
|
|
{
|
|
"templateID": template_id,
|
|
}
|
|
)
|
|
if allow_internet_access is not UNSET:
|
|
field_dict["allow_internet_access"] = allow_internet_access
|
|
if auto_pause is not UNSET:
|
|
field_dict["autoPause"] = auto_pause
|
|
if auto_pause_memory is not UNSET:
|
|
field_dict["autoPauseMemory"] = auto_pause_memory
|
|
if auto_resume is not UNSET:
|
|
field_dict["autoResume"] = auto_resume
|
|
if env_vars is not UNSET:
|
|
field_dict["envVars"] = env_vars
|
|
if mcp is not UNSET:
|
|
field_dict["mcp"] = mcp
|
|
if metadata is not UNSET:
|
|
field_dict["metadata"] = metadata
|
|
if network is not UNSET:
|
|
field_dict["network"] = network
|
|
if secure is not UNSET:
|
|
field_dict["secure"] = secure
|
|
if timeout is not UNSET:
|
|
field_dict["timeout"] = timeout
|
|
if volume_mounts is not UNSET:
|
|
field_dict["volumeMounts"] = volume_mounts
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
|
|
from ..models.mcp_type_0 import McpType0
|
|
from ..models.sandbox_auto_resume_config import SandboxAutoResumeConfig
|
|
from ..models.sandbox_network_config import SandboxNetworkConfig
|
|
from ..models.sandbox_volume_mount import SandboxVolumeMount
|
|
|
|
d = dict(src_dict)
|
|
template_id = d.pop("templateID")
|
|
|
|
allow_internet_access = d.pop("allow_internet_access", UNSET)
|
|
|
|
auto_pause = d.pop("autoPause", UNSET)
|
|
|
|
auto_pause_memory = d.pop("autoPauseMemory", UNSET)
|
|
|
|
_auto_resume = d.pop("autoResume", UNSET)
|
|
auto_resume: Union[Unset, SandboxAutoResumeConfig]
|
|
if isinstance(_auto_resume, Unset):
|
|
auto_resume = UNSET
|
|
else:
|
|
auto_resume = SandboxAutoResumeConfig.from_dict(_auto_resume)
|
|
|
|
env_vars = d.pop("envVars", UNSET)
|
|
|
|
def _parse_mcp(data: object) -> Union["McpType0", None, Unset]:
|
|
if data is None:
|
|
return data
|
|
if isinstance(data, Unset):
|
|
return data
|
|
try:
|
|
if not isinstance(data, dict):
|
|
raise TypeError()
|
|
componentsschemas_mcp_type_0 = McpType0.from_dict(data)
|
|
|
|
return componentsschemas_mcp_type_0
|
|
except: # noqa: E722
|
|
pass
|
|
return cast(Union["McpType0", None, Unset], data)
|
|
|
|
mcp = _parse_mcp(d.pop("mcp", UNSET))
|
|
|
|
metadata = d.pop("metadata", UNSET)
|
|
|
|
_network = d.pop("network", UNSET)
|
|
network: Union[Unset, SandboxNetworkConfig]
|
|
if isinstance(_network, Unset):
|
|
network = UNSET
|
|
else:
|
|
network = SandboxNetworkConfig.from_dict(_network)
|
|
|
|
secure = d.pop("secure", UNSET)
|
|
|
|
timeout = d.pop("timeout", UNSET)
|
|
|
|
volume_mounts = []
|
|
_volume_mounts = d.pop("volumeMounts", UNSET)
|
|
for volume_mounts_item_data in _volume_mounts or []:
|
|
volume_mounts_item = SandboxVolumeMount.from_dict(volume_mounts_item_data)
|
|
|
|
volume_mounts.append(volume_mounts_item)
|
|
|
|
new_sandbox = cls(
|
|
template_id=template_id,
|
|
allow_internet_access=allow_internet_access,
|
|
auto_pause=auto_pause,
|
|
auto_pause_memory=auto_pause_memory,
|
|
auto_resume=auto_resume,
|
|
env_vars=env_vars,
|
|
mcp=mcp,
|
|
metadata=metadata,
|
|
network=network,
|
|
secure=secure,
|
|
timeout=timeout,
|
|
volume_mounts=volume_mounts,
|
|
)
|
|
|
|
new_sandbox.additional_properties = d
|
|
return new_sandbox
|
|
|
|
@property
|
|
def additional_keys(self) -> list[str]:
|
|
return list(self.additional_properties.keys())
|
|
|
|
def __getitem__(self, key: str) -> Any:
|
|
return self.additional_properties[key]
|
|
|
|
def __setitem__(self, key: str, value: Any) -> None:
|
|
self.additional_properties[key] = value
|
|
|
|
def __delitem__(self, key: str) -> None:
|
|
del self.additional_properties[key]
|
|
|
|
def __contains__(self, key: str) -> bool:
|
|
return key in self.additional_properties
|