loopix-sdk 2.30.0__py3-none-any.whl

loopix/api/client/models/new_sandbox.py

@@ -0,0 +1,224 @@
+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

loopix/api/client/models/new_team_api_key.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="NewTeamAPIKey")
+
+
+@_attrs_define
+class NewTeamAPIKey:
+    """
+    Attributes:
+        name (str): Name of the API key
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        new_team_api_key = cls(
+            name=name,
+        )
+
+        new_team_api_key.additional_properties = d
+        return new_team_api_key
+
+    @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

loopix/api/client/models/new_volume.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="NewVolume")
+
+
+@_attrs_define
+class NewVolume:
+    """
+    Attributes:
+        name (str): Name of the volume
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        new_volume = cls(
+            name=name,
+        )
+
+        new_volume.additional_properties = d
+        return new_volume
+
+    @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

loopix/api/client/models/node.py

@@ -0,0 +1,160 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+if TYPE_CHECKING:
+    from ..models.machine_info import MachineInfo
+    from ..models.node_metrics import NodeMetrics
+
+
+T = TypeVar("T", bound="Node")
+
+
+@_attrs_define
+class Node:
+    """
+    Attributes:
+        cluster_id (str): Identifier of the cluster
+        commit (str): Commit of the orchestrator
+        create_fails (int): Number of sandbox create fails
+        create_successes (int): Number of sandbox create successes
+        id (str): Identifier of the node
+        machine_info (MachineInfo):
+        metrics (NodeMetrics): Node metrics
+        sandbox_count (int): Number of sandboxes running on the node
+        sandbox_starting_count (int): Number of starting Sandboxes
+        service_instance_id (str): Service instance identifier of the node
+        status (NodeStatus): Status of the node.
+            - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing
+            sandboxes are done.
+            - standby: the node is not actively used, but it can return to ready and continue serving traffic.
+        version (str): Version of the orchestrator
+    """
+
+    cluster_id: str
+    commit: str
+    create_fails: int
+    create_successes: int
+    id: str
+    machine_info: "MachineInfo"
+    metrics: "NodeMetrics"
+    sandbox_count: int
+    sandbox_starting_count: int
+    service_instance_id: str
+    status: NodeStatus
+    version: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cluster_id = self.cluster_id
+
+        commit = self.commit
+
+        create_fails = self.create_fails
+
+        create_successes = self.create_successes
+
+        id = self.id
+
+        machine_info = self.machine_info.to_dict()
+
+        metrics = self.metrics.to_dict()
+
+        sandbox_count = self.sandbox_count
+
+        sandbox_starting_count = self.sandbox_starting_count
+
+        service_instance_id = self.service_instance_id
+
+        status = self.status.value
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clusterID": cluster_id,
+                "commit": commit,
+                "createFails": create_fails,
+                "createSuccesses": create_successes,
+                "id": id,
+                "machineInfo": machine_info,
+                "metrics": metrics,
+                "sandboxCount": sandbox_count,
+                "sandboxStartingCount": sandbox_starting_count,
+                "serviceInstanceID": service_instance_id,
+                "status": status,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.machine_info import MachineInfo
+        from ..models.node_metrics import NodeMetrics
+
+        d = dict(src_dict)
+        cluster_id = d.pop("clusterID")
+
+        commit = d.pop("commit")
+
+        create_fails = d.pop("createFails")
+
+        create_successes = d.pop("createSuccesses")
+
+        id = d.pop("id")
+
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
+        metrics = NodeMetrics.from_dict(d.pop("metrics"))
+
+        sandbox_count = d.pop("sandboxCount")
+
+        sandbox_starting_count = d.pop("sandboxStartingCount")
+
+        service_instance_id = d.pop("serviceInstanceID")
+
+        status = NodeStatus(d.pop("status"))
+
+        version = d.pop("version")
+
+        node = cls(
+            cluster_id=cluster_id,
+            commit=commit,
+            create_fails=create_fails,
+            create_successes=create_successes,
+            id=id,
+            machine_info=machine_info,
+            metrics=metrics,
+            sandbox_count=sandbox_count,
+            sandbox_starting_count=sandbox_starting_count,
+            service_instance_id=service_instance_id,
+            status=status,
+            version=version,
+        )
+
+        node.additional_properties = d
+        return node
+
+    @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

loopix/api/client/models/node_detail.py

@@ -0,0 +1,160 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+if TYPE_CHECKING:
+    from ..models.machine_info import MachineInfo
+    from ..models.node_metrics import NodeMetrics
+
+
+T = TypeVar("T", bound="NodeDetail")
+
+
+@_attrs_define
+class NodeDetail:
+    """
+    Attributes:
+        cached_builds (list[str]): List of cached builds id on the node
+        cluster_id (str): Identifier of the cluster
+        commit (str): Commit of the orchestrator
+        create_fails (int): Number of sandbox create fails
+        create_successes (int): Number of sandbox create successes
+        id (str): Identifier of the node
+        machine_info (MachineInfo):
+        metrics (NodeMetrics): Node metrics
+        sandbox_count (int): Number of sandboxes running on the node
+        service_instance_id (str): Service instance identifier of the node
+        status (NodeStatus): Status of the node.
+            - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing
+            sandboxes are done.
+            - standby: the node is not actively used, but it can return to ready and continue serving traffic.
+        version (str): Version of the orchestrator
+    """
+
+    cached_builds: list[str]
+    cluster_id: str
+    commit: str
+    create_fails: int
+    create_successes: int
+    id: str
+    machine_info: "MachineInfo"
+    metrics: "NodeMetrics"
+    sandbox_count: int
+    service_instance_id: str
+    status: NodeStatus
+    version: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cached_builds = self.cached_builds
+
+        cluster_id = self.cluster_id
+
+        commit = self.commit
+
+        create_fails = self.create_fails
+
+        create_successes = self.create_successes
+
+        id = self.id
+
+        machine_info = self.machine_info.to_dict()
+
+        metrics = self.metrics.to_dict()
+
+        sandbox_count = self.sandbox_count
+
+        service_instance_id = self.service_instance_id
+
+        status = self.status.value
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cachedBuilds": cached_builds,
+                "clusterID": cluster_id,
+                "commit": commit,
+                "createFails": create_fails,
+                "createSuccesses": create_successes,
+                "id": id,
+                "machineInfo": machine_info,
+                "metrics": metrics,
+                "sandboxCount": sandbox_count,
+                "serviceInstanceID": service_instance_id,
+                "status": status,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.machine_info import MachineInfo
+        from ..models.node_metrics import NodeMetrics
+
+        d = dict(src_dict)
+        cached_builds = cast(list[str], d.pop("cachedBuilds"))
+
+        cluster_id = d.pop("clusterID")
+
+        commit = d.pop("commit")
+
+        create_fails = d.pop("createFails")
+
+        create_successes = d.pop("createSuccesses")
+
+        id = d.pop("id")
+
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
+        metrics = NodeMetrics.from_dict(d.pop("metrics"))
+
+        sandbox_count = d.pop("sandboxCount")
+
+        service_instance_id = d.pop("serviceInstanceID")
+
+        status = NodeStatus(d.pop("status"))
+
+        version = d.pop("version")
+
+        node_detail = cls(
+            cached_builds=cached_builds,
+            cluster_id=cluster_id,
+            commit=commit,
+            create_fails=create_fails,
+            create_successes=create_successes,
+            id=id,
+            machine_info=machine_info,
+            metrics=metrics,
+            sandbox_count=sandbox_count,
+            service_instance_id=service_instance_id,
+            status=status,
+            version=version,
+        )
+
+        node_detail.additional_properties = d
+        return node_detail
+
+    @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