loopix-sdk 2.30.0__py3-none-any.whl

loopix/api/client/models/sandbox_detail.py

@@ -0,0 +1,267 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.sandbox_state import SandboxState
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_lifecycle import SandboxLifecycle
+    from ..models.sandbox_network_config import SandboxNetworkConfig
+    from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+
+T = TypeVar("T", bound="SandboxDetail")
+
+
+@_attrs_define
+class SandboxDetail:
+    """
+    Attributes:
+        client_id (str): Identifier of the client
+        cpu_count (int): CPU cores for the sandbox
+        disk_size_mb (int): Disk size for the sandbox in MiB
+        end_at (datetime.datetime): Time when the sandbox will expire
+        envd_version (str): Version of the envd running in the sandbox
+        memory_mb (int): Memory for the sandbox in MiB
+        sandbox_id (str): Identifier of the sandbox
+        started_at (datetime.datetime): Time when the sandbox was started
+        state (SandboxState): State of the sandbox
+        template_id (str): Identifier of the template from which is the sandbox created
+        alias (Union[Unset, str]): Alias of the template
+        allow_internet_access (Union[None, Unset, bool]): Whether internet access was explicitly enabled or disabled for
+            the sandbox. Null means it was not explicitly set.
+        domain (Union[None, Unset, str]): Base domain where the sandbox traffic is accessible
+        envd_access_token (Union[Unset, str]): Access token used for envd communication
+        lifecycle (Union[Unset, SandboxLifecycle]): Sandbox lifecycle policy returned by sandbox info.
+        metadata (Union[Unset, Any]):
+        network (Union[Unset, SandboxNetworkConfig]):
+        volume_mounts (Union[Unset, list['SandboxVolumeMount']]):
+    """
+
+    client_id: str
+    cpu_count: int
+    disk_size_mb: int
+    end_at: datetime.datetime
+    envd_version: str
+    memory_mb: int
+    sandbox_id: str
+    started_at: datetime.datetime
+    state: SandboxState
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    allow_internet_access: Union[None, Unset, bool] = UNSET
+    domain: Union[None, Unset, str] = UNSET
+    envd_access_token: Union[Unset, str] = UNSET
+    lifecycle: Union[Unset, "SandboxLifecycle"] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    network: Union[Unset, "SandboxNetworkConfig"] = UNSET
+    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]:
+        client_id = self.client_id
+
+        cpu_count = self.cpu_count
+
+        disk_size_mb = self.disk_size_mb
+
+        end_at = self.end_at.isoformat()
+
+        envd_version = self.envd_version
+
+        memory_mb = self.memory_mb
+
+        sandbox_id = self.sandbox_id
+
+        started_at = self.started_at.isoformat()
+
+        state = self.state.value
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        allow_internet_access: Union[None, Unset, bool]
+        if isinstance(self.allow_internet_access, Unset):
+            allow_internet_access = UNSET
+        else:
+            allow_internet_access = self.allow_internet_access
+
+        domain: Union[None, Unset, str]
+        if isinstance(self.domain, Unset):
+            domain = UNSET
+        else:
+            domain = self.domain
+
+        envd_access_token = self.envd_access_token
+
+        lifecycle: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.lifecycle, Unset):
+            lifecycle = self.lifecycle.to_dict()
+
+        metadata = self.metadata
+
+        network: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.network, Unset):
+            network = self.network.to_dict()
+
+        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(
+            {
+                "clientID": client_id,
+                "cpuCount": cpu_count,
+                "diskSizeMB": disk_size_mb,
+                "endAt": end_at,
+                "envdVersion": envd_version,
+                "memoryMB": memory_mb,
+                "sandboxID": sandbox_id,
+                "startedAt": started_at,
+                "state": state,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if allow_internet_access is not UNSET:
+            field_dict["allowInternetAccess"] = allow_internet_access
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if envd_access_token is not UNSET:
+            field_dict["envdAccessToken"] = envd_access_token
+        if lifecycle is not UNSET:
+            field_dict["lifecycle"] = lifecycle
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if network is not UNSET:
+            field_dict["network"] = network
+        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.sandbox_lifecycle import SandboxLifecycle
+        from ..models.sandbox_network_config import SandboxNetworkConfig
+        from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+        d = dict(src_dict)
+        client_id = d.pop("clientID")
+
+        cpu_count = d.pop("cpuCount")
+
+        disk_size_mb = d.pop("diskSizeMB")
+
+        end_at = isoparse(d.pop("endAt"))
+
+        envd_version = d.pop("envdVersion")
+
+        memory_mb = d.pop("memoryMB")
+
+        sandbox_id = d.pop("sandboxID")
+
+        started_at = isoparse(d.pop("startedAt"))
+
+        state = SandboxState(d.pop("state"))
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", UNSET)
+
+        def _parse_allow_internet_access(data: object) -> Union[None, Unset, bool]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, bool], data)
+
+        allow_internet_access = _parse_allow_internet_access(
+            d.pop("allowInternetAccess", UNSET)
+        )
+
+        def _parse_domain(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        domain = _parse_domain(d.pop("domain", UNSET))
+
+        envd_access_token = d.pop("envdAccessToken", UNSET)
+
+        _lifecycle = d.pop("lifecycle", UNSET)
+        lifecycle: Union[Unset, SandboxLifecycle]
+        if isinstance(_lifecycle, Unset):
+            lifecycle = UNSET
+        else:
+            lifecycle = SandboxLifecycle.from_dict(_lifecycle)
+
+        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)
+
+        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)
+
+        sandbox_detail = cls(
+            client_id=client_id,
+            cpu_count=cpu_count,
+            disk_size_mb=disk_size_mb,
+            end_at=end_at,
+            envd_version=envd_version,
+            memory_mb=memory_mb,
+            sandbox_id=sandbox_id,
+            started_at=started_at,
+            state=state,
+            template_id=template_id,
+            alias=alias,
+            allow_internet_access=allow_internet_access,
+            domain=domain,
+            envd_access_token=envd_access_token,
+            lifecycle=lifecycle,
+            metadata=metadata,
+            network=network,
+            volume_mounts=volume_mounts,
+        )
+
+        sandbox_detail.additional_properties = d
+        return sandbox_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

loopix/api/client/models/sandbox_lifecycle.py

@@ -0,0 +1,70 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.sandbox_on_timeout import SandboxOnTimeout
+
+T = TypeVar("T", bound="SandboxLifecycle")
+
+
+@_attrs_define
+class SandboxLifecycle:
+    """Sandbox lifecycle policy returned by sandbox info.
+
+    Attributes:
+        auto_resume (bool): Whether the sandbox can auto-resume.
+        on_timeout (SandboxOnTimeout): Action taken when the sandbox times out.
+    """
+
+    auto_resume: bool
+    on_timeout: SandboxOnTimeout
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        auto_resume = self.auto_resume
+
+        on_timeout = self.on_timeout.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "autoResume": auto_resume,
+                "onTimeout": on_timeout,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        auto_resume = d.pop("autoResume")
+
+        on_timeout = SandboxOnTimeout(d.pop("onTimeout"))
+
+        sandbox_lifecycle = cls(
+            auto_resume=auto_resume,
+            on_timeout=on_timeout,
+        )
+
+        sandbox_lifecycle.additional_properties = d
+        return sandbox_lifecycle
+
+    @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/sandbox_log.py

@@ -0,0 +1,70 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="SandboxLog")
+
+
+@_attrs_define
+class SandboxLog:
+    """Log entry with timestamp and line
+
+    Attributes:
+        line (str): Log line content
+        timestamp (datetime.datetime): Timestamp of the log entry
+    """
+
+    line: str
+    timestamp: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        line = self.line
+
+        timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "line": line,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        line = d.pop("line")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        sandbox_log = cls(
+            line=line,
+            timestamp=timestamp,
+        )
+
+        sandbox_log.additional_properties = d
+        return sandbox_log
+
+    @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/sandbox_log_entry.py

@@ -0,0 +1,93 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.log_level import LogLevel
+
+if TYPE_CHECKING:
+    from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
+
+
+T = TypeVar("T", bound="SandboxLogEntry")
+
+
+@_attrs_define
+class SandboxLogEntry:
+    """
+    Attributes:
+        fields (SandboxLogEntryFields):
+        level (LogLevel): State of the sandbox
+        message (str): Log message content
+        timestamp (datetime.datetime): Timestamp of the log entry
+    """
+
+    fields: "SandboxLogEntryFields"
+    level: LogLevel
+    message: str
+    timestamp: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        fields = self.fields.to_dict()
+
+        level = self.level.value
+
+        message = self.message
+
+        timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "fields": fields,
+                "level": level,
+                "message": message,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
+
+        d = dict(src_dict)
+        fields = SandboxLogEntryFields.from_dict(d.pop("fields"))
+
+        level = LogLevel(d.pop("level"))
+
+        message = d.pop("message")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        sandbox_log_entry = cls(
+            fields=fields,
+            level=level,
+            message=message,
+            timestamp=timestamp,
+        )
+
+        sandbox_log_entry.additional_properties = d
+        return sandbox_log_entry
+
+    @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/sandbox_log_entry_fields.py

@@ -0,0 +1,44 @@
+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="SandboxLogEntryFields")
+
+
+@_attrs_define
+class SandboxLogEntryFields:
+    """ """
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sandbox_log_entry_fields = cls()
+
+        sandbox_log_entry_fields.additional_properties = d
+        return sandbox_log_entry_fields
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/sandbox_logs.py

@@ -0,0 +1,91 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.sandbox_log import SandboxLog
+    from ..models.sandbox_log_entry import SandboxLogEntry
+
+
+T = TypeVar("T", bound="SandboxLogs")
+
+
+@_attrs_define
+class SandboxLogs:
+    """
+    Attributes:
+        log_entries (list['SandboxLogEntry']): Structured logs of the sandbox
+        logs (list['SandboxLog']): Logs of the sandbox
+    """
+
+    log_entries: list["SandboxLogEntry"]
+    logs: list["SandboxLog"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        log_entries = []
+        for log_entries_item_data in self.log_entries:
+            log_entries_item = log_entries_item_data.to_dict()
+            log_entries.append(log_entries_item)
+
+        logs = []
+        for logs_item_data in self.logs:
+            logs_item = logs_item_data.to_dict()
+            logs.append(logs_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "logEntries": log_entries,
+                "logs": logs,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_log import SandboxLog
+        from ..models.sandbox_log_entry import SandboxLogEntry
+
+        d = dict(src_dict)
+        log_entries = []
+        _log_entries = d.pop("logEntries")
+        for log_entries_item_data in _log_entries:
+            log_entries_item = SandboxLogEntry.from_dict(log_entries_item_data)
+
+            log_entries.append(log_entries_item)
+
+        logs = []
+        _logs = d.pop("logs")
+        for logs_item_data in _logs:
+            logs_item = SandboxLog.from_dict(logs_item_data)
+
+            logs.append(logs_item)
+
+        sandbox_logs = cls(
+            log_entries=log_entries,
+            logs=logs,
+        )
+
+        sandbox_logs.additional_properties = d
+        return sandbox_logs
+
+    @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