moru 0.1.0__py3-none-any.whl

moru/api/client/models/post_sandboxes_sandbox_id_timeout_body.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="PostSandboxesSandboxIDTimeoutBody")
+
+
+@_attrs_define
+class PostSandboxesSandboxIDTimeoutBody:
+    """
+    Attributes:
+        timeout (int): Timeout in seconds from the current time after which the sandbox should expire
+    """
+
+    timeout: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timeout": timeout,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        timeout = d.pop("timeout")
+
+        post_sandboxes_sandbox_id_timeout_body = cls(
+            timeout=timeout,
+        )
+
+        post_sandboxes_sandbox_id_timeout_body.additional_properties = d
+        return post_sandboxes_sandbox_id_timeout_body
+
+    @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

moru/api/client/models/resumed_sandbox.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ResumedSandbox")
+
+
+@_attrs_define
+class ResumedSandbox:
+    """
+    Attributes:
+        auto_pause (Union[Unset, bool]): Automatically pauses the sandbox after the timeout
+        timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
+    """
+
+    auto_pause: Union[Unset, bool] = UNSET
+    timeout: Union[Unset, int] = 15
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        auto_pause = self.auto_pause
+
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if auto_pause is not UNSET:
+            field_dict["autoPause"] = auto_pause
+        if timeout is not UNSET:
+            field_dict["timeout"] = timeout
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        auto_pause = d.pop("autoPause", UNSET)
+
+        timeout = d.pop("timeout", UNSET)
+
+        resumed_sandbox = cls(
+            auto_pause=auto_pause,
+            timeout=timeout,
+        )
+
+        resumed_sandbox.additional_properties = d
+        return resumed_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

moru/api/client/models/sandbox.py

@@ -0,0 +1,145 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Sandbox")
+
+
+@_attrs_define
+class Sandbox:
+    """
+    Attributes:
+        client_id (str): Identifier of the client
+        envd_version (str): Version of the envd running in the sandbox
+        sandbox_id (str): Identifier of the sandbox
+        template_id (str): Identifier of the template from which is the sandbox created
+        alias (Union[Unset, str]): Alias of the template
+        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
+        traffic_access_token (Union[None, Unset, str]): Token required for accessing sandbox via proxy.
+    """
+
+    client_id: str
+    envd_version: str
+    sandbox_id: str
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    domain: Union[None, Unset, str] = UNSET
+    envd_access_token: Union[Unset, str] = UNSET
+    traffic_access_token: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        client_id = self.client_id
+
+        envd_version = self.envd_version
+
+        sandbox_id = self.sandbox_id
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        domain: Union[None, Unset, str]
+        if isinstance(self.domain, Unset):
+            domain = UNSET
+        else:
+            domain = self.domain
+
+        envd_access_token = self.envd_access_token
+
+        traffic_access_token: Union[None, Unset, str]
+        if isinstance(self.traffic_access_token, Unset):
+            traffic_access_token = UNSET
+        else:
+            traffic_access_token = self.traffic_access_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "clientID": client_id,
+                "envdVersion": envd_version,
+                "sandboxID": sandbox_id,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if envd_access_token is not UNSET:
+            field_dict["envdAccessToken"] = envd_access_token
+        if traffic_access_token is not UNSET:
+            field_dict["trafficAccessToken"] = traffic_access_token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        client_id = d.pop("clientID")
+
+        envd_version = d.pop("envdVersion")
+
+        sandbox_id = d.pop("sandboxID")
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", 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)
+
+        def _parse_traffic_access_token(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)
+
+        traffic_access_token = _parse_traffic_access_token(
+            d.pop("trafficAccessToken", UNSET)
+        )
+
+        sandbox = cls(
+            client_id=client_id,
+            envd_version=envd_version,
+            sandbox_id=sandbox_id,
+            template_id=template_id,
+            alias=alias,
+            domain=domain,
+            envd_access_token=envd_access_token,
+            traffic_access_token=traffic_access_token,
+        )
+
+        sandbox.additional_properties = d
+        return 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

moru/api/client/models/sandbox_detail.py

@@ -0,0 +1,183 @@
+import datetime
+from collections.abc import Mapping
+from typing import 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
+
+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
+        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
+        metadata (Union[Unset, Any]):
+    """
+
+    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
+    domain: Union[None, Unset, str] = UNSET
+    envd_access_token: Union[Unset, str] = UNSET
+    metadata: Union[Unset, Any] = 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
+
+        domain: Union[None, Unset, str]
+        if isinstance(self.domain, Unset):
+            domain = UNSET
+        else:
+            domain = self.domain
+
+        envd_access_token = self.envd_access_token
+
+        metadata = self.metadata
+
+        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 domain is not UNSET:
+            field_dict["domain"] = domain
+        if envd_access_token is not UNSET:
+            field_dict["envdAccessToken"] = envd_access_token
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        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_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)
+
+        metadata = d.pop("metadata", UNSET)
+
+        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,
+            domain=domain,
+            envd_access_token=envd_access_token,
+            metadata=metadata,
+        )
+
+        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

moru/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

moru/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

moru/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