moru 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

moru/api/client/models/node.py

@@ -7,6 +7,7 @@ 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
 
 
@@ -22,6 +23,7 @@ class Node:
         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
         node_id (str): Identifier of the nomad node
         sandbox_count (int): Number of sandboxes running on the node
@@ -36,6 +38,7 @@ class Node:
     create_fails: int
     create_successes: int
     id: str
+    machine_info: "MachineInfo"
     metrics: "NodeMetrics"
     node_id: str
     sandbox_count: int
@@ -56,6 +59,8 @@ class Node:
 
         id = self.id
 
+        machine_info = self.machine_info.to_dict()
+
         metrics = self.metrics.to_dict()
 
         node_id = self.node_id
@@ -79,6 +84,7 @@ class Node:
                 "createFails": create_fails,
                 "createSuccesses": create_successes,
                 "id": id,
+                "machineInfo": machine_info,
                 "metrics": metrics,
                 "nodeID": node_id,
                 "sandboxCount": sandbox_count,
@@ -93,6 +99,7 @@ class Node:
 
     @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)
@@ -106,6 +113,8 @@ class Node:
 
         id = d.pop("id")
 
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
         metrics = NodeMetrics.from_dict(d.pop("metrics"))
 
         node_id = d.pop("nodeID")
@@ -126,6 +135,7 @@ class Node:
             create_fails=create_fails,
             create_successes=create_successes,
             id=id,
+            machine_info=machine_info,
             metrics=metrics,
             node_id=node_id,
             sandbox_count=sandbox_count,

moru/api/client/models/node_detail.py

@@ -8,6 +8,7 @@ from ..models.node_status import NodeStatus
 
 if TYPE_CHECKING:
     from ..models.listed_sandbox import ListedSandbox
+    from ..models.machine_info import MachineInfo
     from ..models.node_metrics import NodeMetrics
 
 
@@ -24,6 +25,7 @@ class NodeDetail:
         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
         node_id (str): Identifier of the nomad node
         sandboxes (list['ListedSandbox']): List of sandboxes running on the node
@@ -38,6 +40,7 @@ class NodeDetail:
     create_fails: int
     create_successes: int
     id: str
+    machine_info: "MachineInfo"
     metrics: "NodeMetrics"
     node_id: str
     sandboxes: list["ListedSandbox"]
@@ -59,6 +62,8 @@ class NodeDetail:
 
         id = self.id
 
+        machine_info = self.machine_info.to_dict()
+
         metrics = self.metrics.to_dict()
 
         node_id = self.node_id
@@ -84,6 +89,7 @@ class NodeDetail:
                 "createFails": create_fails,
                 "createSuccesses": create_successes,
                 "id": id,
+                "machineInfo": machine_info,
                 "metrics": metrics,
                 "nodeID": node_id,
                 "sandboxes": sandboxes,
@@ -98,6 +104,7 @@ class NodeDetail:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.listed_sandbox import ListedSandbox
+        from ..models.machine_info import MachineInfo
         from ..models.node_metrics import NodeMetrics
 
         d = dict(src_dict)
@@ -113,6 +120,8 @@ class NodeDetail:
 
         id = d.pop("id")
 
+        machine_info = MachineInfo.from_dict(d.pop("machineInfo"))
+
         metrics = NodeMetrics.from_dict(d.pop("metrics"))
 
         node_id = d.pop("nodeID")
@@ -137,6 +146,7 @@ class NodeDetail:
             create_fails=create_fails,
             create_successes=create_successes,
             id=id,
+            machine_info=machine_info,
             metrics=metrics,
             node_id=node_id,
             sandboxes=sandboxes,

moru/api/client/models/sandbox_log_entry.py

@@ -6,7 +6,7 @@ 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
+from ..models.sandbox_log_event_type import SandboxLogEventType
 
 if TYPE_CHECKING:
     from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
@@ -19,22 +19,22 @@ T = TypeVar("T", bound="SandboxLogEntry")
 class SandboxLogEntry:
     """
     Attributes:
+        event_type (SandboxLogEventType): Type of sandbox log event
         fields (SandboxLogEntryFields):
-        level (LogLevel): State of the sandbox
         message (str): Log message content
         timestamp (datetime.datetime): Timestamp of the log entry
     """
 
+    event_type: SandboxLogEventType
     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()
+        event_type = self.event_type.value
 
-        level = self.level.value
+        fields = self.fields.to_dict()
 
         message = self.message
 
@@ -44,8 +44,8 @@ class SandboxLogEntry:
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
+                "eventType": event_type,
                 "fields": fields,
-                "level": level,
                 "message": message,
                 "timestamp": timestamp,
             }
@@ -58,17 +58,17 @@ class SandboxLogEntry:
         from ..models.sandbox_log_entry_fields import SandboxLogEntryFields
 
         d = dict(src_dict)
-        fields = SandboxLogEntryFields.from_dict(d.pop("fields"))
+        event_type = SandboxLogEventType(d.pop("eventType"))
 
-        level = LogLevel(d.pop("level"))
+        fields = SandboxLogEntryFields.from_dict(d.pop("fields"))
 
         message = d.pop("message")
 
         timestamp = isoparse(d.pop("timestamp"))
 
         sandbox_log_entry = cls(
+            event_type=event_type,
             fields=fields,
-            level=level,
             message=message,
             timestamp=timestamp,
         )

moru/api/client/models/sandbox_log_event_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SandboxLogEventType(str, Enum):
+    PROCESS_END = "process_end"
+    PROCESS_START = "process_start"
+    STDERR = "stderr"
+    STDOUT = "stdout"
+
+    def __str__(self) -> str:
+        return str(self.value)

moru/api/client/models/sandbox_run.py

@@ -0,0 +1,130 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.sandbox_run_end_reason import SandboxRunEndReason
+from ..models.sandbox_run_status import SandboxRunStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SandboxRun")
+
+
+@_attrs_define
+class SandboxRun:
+    """
+    Attributes:
+        created_at (datetime.datetime): When the sandbox was created
+        sandbox_id (str): Unique sandbox identifier
+        status (SandboxRunStatus): Status of a sandbox run
+        template_id (str): Template used to create the sandbox
+        alias (Union[Unset, str]): Template alias
+        end_reason (Union[Unset, SandboxRunEndReason]): Reason the sandbox stopped
+        ended_at (Union[Unset, datetime.datetime]): When the sandbox stopped
+    """
+
+    created_at: datetime.datetime
+    sandbox_id: str
+    status: SandboxRunStatus
+    template_id: str
+    alias: Union[Unset, str] = UNSET
+    end_reason: Union[Unset, SandboxRunEndReason] = UNSET
+    ended_at: Union[Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        sandbox_id = self.sandbox_id
+
+        status = self.status.value
+
+        template_id = self.template_id
+
+        alias = self.alias
+
+        end_reason: Union[Unset, str] = UNSET
+        if not isinstance(self.end_reason, Unset):
+            end_reason = self.end_reason.value
+
+        ended_at: Union[Unset, str] = UNSET
+        if not isinstance(self.ended_at, Unset):
+            ended_at = self.ended_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "sandboxID": sandbox_id,
+                "status": status,
+                "templateID": template_id,
+            }
+        )
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if end_reason is not UNSET:
+            field_dict["endReason"] = end_reason
+        if ended_at is not UNSET:
+            field_dict["endedAt"] = ended_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        sandbox_id = d.pop("sandboxID")
+
+        status = SandboxRunStatus(d.pop("status"))
+
+        template_id = d.pop("templateID")
+
+        alias = d.pop("alias", UNSET)
+
+        _end_reason = d.pop("endReason", UNSET)
+        end_reason: Union[Unset, SandboxRunEndReason]
+        if isinstance(_end_reason, Unset):
+            end_reason = UNSET
+        else:
+            end_reason = SandboxRunEndReason(_end_reason)
+
+        _ended_at = d.pop("endedAt", UNSET)
+        ended_at: Union[Unset, datetime.datetime]
+        if isinstance(_ended_at, Unset):
+            ended_at = UNSET
+        else:
+            ended_at = isoparse(_ended_at)
+
+        sandbox_run = cls(
+            created_at=created_at,
+            sandbox_id=sandbox_id,
+            status=status,
+            template_id=template_id,
+            alias=alias,
+            end_reason=end_reason,
+            ended_at=ended_at,
+        )
+
+        sandbox_run.additional_properties = d
+        return sandbox_run
+
+    @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_run_end_reason.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SandboxRunEndReason(str, Enum):
+    ERROR = "error"
+    KILLED = "killed"
+    SHUTDOWN = "shutdown"
+    TIMEOUT = "timeout"
+
+    def __str__(self) -> str:
+        return str(self.value)

moru/api/client/models/sandbox_run_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SandboxRunStatus(str, Enum):
+    PAUSED = "paused"
+    RUNNING = "running"
+    STOPPED = "stopped"
+
+    def __str__(self) -> str:
+        return str(self.value)

moru/api/client/models/template_build_logs_response.py

@@ -0,0 +1,73 @@
+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.build_log_entry import BuildLogEntry
+
+
+T = TypeVar("T", bound="TemplateBuildLogsResponse")
+
+
+@_attrs_define
+class TemplateBuildLogsResponse:
+    """
+    Attributes:
+        logs (list['BuildLogEntry']): Build logs structured
+    """
+
+    logs: list["BuildLogEntry"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "logs": logs,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.build_log_entry import BuildLogEntry
+
+        d = dict(src_dict)
+        logs = []
+        _logs = d.pop("logs")
+        for logs_item_data in _logs:
+            logs_item = BuildLogEntry.from_dict(logs_item_data)
+
+            logs.append(logs_item)
+
+        template_build_logs_response = cls(
+            logs=logs,
+        )
+
+        template_build_logs_response.additional_properties = d
+        return template_build_logs_response
+
+    @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/upload_response.py

@@ -0,0 +1,67 @@
+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="UploadResponse")
+
+
+@_attrs_define
+class UploadResponse:
+    """
+    Attributes:
+        path (str): Path of uploaded file
+        size (int): Size of uploaded file in bytes
+    """
+
+    path: str
+    size: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        path = self.path
+
+        size = self.size
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "path": path,
+                "size": size,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        path = d.pop("path")
+
+        size = d.pop("size")
+
+        upload_response = cls(
+            path=path,
+            size=size,
+        )
+
+        upload_response.additional_properties = d
+        return upload_response
+
+    @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/volume.py

@@ -0,0 +1,105 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Volume")
+
+
+@_attrs_define
+class Volume:
+    """
+    Attributes:
+        created_at (datetime.datetime): When the volume was created
+        name (str): Volume name
+        updated_at (datetime.datetime): When the volume was last updated
+        volume_id (str): Unique volume identifier
+        total_file_count (Union[Unset, int]): Total number of files in volume
+        total_size_bytes (Union[Unset, int]): Total size of files in volume (bytes)
+    """
+
+    created_at: datetime.datetime
+    name: str
+    updated_at: datetime.datetime
+    volume_id: str
+    total_file_count: Union[Unset, int] = UNSET
+    total_size_bytes: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        name = self.name
+
+        updated_at = self.updated_at.isoformat()
+
+        volume_id = self.volume_id
+
+        total_file_count = self.total_file_count
+
+        total_size_bytes = self.total_size_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "name": name,
+                "updatedAt": updated_at,
+                "volumeID": volume_id,
+            }
+        )
+        if total_file_count is not UNSET:
+            field_dict["totalFileCount"] = total_file_count
+        if total_size_bytes is not UNSET:
+            field_dict["totalSizeBytes"] = total_size_bytes
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        name = d.pop("name")
+
+        updated_at = isoparse(d.pop("updatedAt"))
+
+        volume_id = d.pop("volumeID")
+
+        total_file_count = d.pop("totalFileCount", UNSET)
+
+        total_size_bytes = d.pop("totalSizeBytes", UNSET)
+
+        volume = cls(
+            created_at=created_at,
+            name=name,
+            updated_at=updated_at,
+            volume_id=volume_id,
+            total_file_count=total_file_count,
+            total_size_bytes=total_size_bytes,
+        )
+
+        volume.additional_properties = d
+        return 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