loopix-sdk 2.30.0__py3-none-any.whl

loopix/api/client/models/identifier_masking_details.py

@@ -0,0 +1,83 @@
+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="IdentifierMaskingDetails")
+
+
+@_attrs_define
+class IdentifierMaskingDetails:
+    """
+    Attributes:
+        masked_value_prefix (str): Prefix used in masked version of the token or key
+        masked_value_suffix (str): Suffix used in masked version of the token or key
+        prefix (str): Prefix that identifies the token or key type
+        value_length (int): Length of the token or key
+    """
+
+    masked_value_prefix: str
+    masked_value_suffix: str
+    prefix: str
+    value_length: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        masked_value_prefix = self.masked_value_prefix
+
+        masked_value_suffix = self.masked_value_suffix
+
+        prefix = self.prefix
+
+        value_length = self.value_length
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "maskedValuePrefix": masked_value_prefix,
+                "maskedValueSuffix": masked_value_suffix,
+                "prefix": prefix,
+                "valueLength": value_length,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        masked_value_prefix = d.pop("maskedValuePrefix")
+
+        masked_value_suffix = d.pop("maskedValueSuffix")
+
+        prefix = d.pop("prefix")
+
+        value_length = d.pop("valueLength")
+
+        identifier_masking_details = cls(
+            masked_value_prefix=masked_value_prefix,
+            masked_value_suffix=masked_value_suffix,
+            prefix=prefix,
+            value_length=value_length,
+        )
+
+        identifier_masking_details.additional_properties = d
+        return identifier_masking_details
+
+    @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/listed_sandbox.py

@@ -0,0 +1,179 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, 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_state import SandboxState
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_volume_mount import SandboxVolumeMount
+
+
+T = TypeVar("T", bound="ListedSandbox")
+
+
+@_attrs_define
+class ListedSandbox:
+    """
+    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
+        metadata (Union[Unset, Any]):
+        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
+    metadata: Union[Unset, Any] = 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
+
+        metadata = self.metadata
+
+        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 metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        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_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)
+
+        metadata = d.pop("metadata", 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)
+
+        listed_sandbox = 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,
+            metadata=metadata,
+            volume_mounts=volume_mounts,
+        )
+
+        listed_sandbox.additional_properties = d
+        return listed_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/log_level.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class LogLevel(str, Enum):
+    DEBUG = "debug"
+    ERROR = "error"
+    INFO = "info"
+    WARN = "warn"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/logs_direction.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LogsDirection(str, Enum):
+    BACKWARD = "backward"
+    FORWARD = "forward"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/logs_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LogsSource(str, Enum):
+    PERSISTENT = "persistent"
+    TEMPORARY = "temporary"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/machine_info.py

@@ -0,0 +1,83 @@
+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="MachineInfo")
+
+
+@_attrs_define
+class MachineInfo:
+    """
+    Attributes:
+        cpu_architecture (str): CPU architecture of the node
+        cpu_family (str): CPU family of the node
+        cpu_model (str): CPU model of the node
+        cpu_model_name (str): CPU model name of the node
+    """
+
+    cpu_architecture: str
+    cpu_family: str
+    cpu_model: str
+    cpu_model_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cpu_architecture = self.cpu_architecture
+
+        cpu_family = self.cpu_family
+
+        cpu_model = self.cpu_model
+
+        cpu_model_name = self.cpu_model_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cpuArchitecture": cpu_architecture,
+                "cpuFamily": cpu_family,
+                "cpuModel": cpu_model,
+                "cpuModelName": cpu_model_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cpu_architecture = d.pop("cpuArchitecture")
+
+        cpu_family = d.pop("cpuFamily")
+
+        cpu_model = d.pop("cpuModel")
+
+        cpu_model_name = d.pop("cpuModelName")
+
+        machine_info = cls(
+            cpu_architecture=cpu_architecture,
+            cpu_family=cpu_family,
+            cpu_model=cpu_model,
+            cpu_model_name=cpu_model_name,
+        )
+
+        machine_info.additional_properties = d
+        return machine_info
+
+    @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/max_team_metric.py

@@ -0,0 +1,78 @@
+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="MaxTeamMetric")
+
+
+@_attrs_define
+class MaxTeamMetric:
+    """Team metric with timestamp
+
+    Attributes:
+        timestamp (datetime.datetime): Timestamp of the metric entry
+        timestamp_unix (int): Timestamp of the metric entry in Unix time (seconds since epoch)
+        value (float): The maximum value of the requested metric in the given interval
+    """
+
+    timestamp: datetime.datetime
+    timestamp_unix: int
+    value: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        timestamp = self.timestamp.isoformat()
+
+        timestamp_unix = self.timestamp_unix
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timestamp": timestamp,
+                "timestampUnix": timestamp_unix,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        timestamp = isoparse(d.pop("timestamp"))
+
+        timestamp_unix = d.pop("timestampUnix")
+
+        value = d.pop("value")
+
+        max_team_metric = cls(
+            timestamp=timestamp,
+            timestamp_unix=timestamp_unix,
+            value=value,
+        )
+
+        max_team_metric.additional_properties = d
+        return max_team_metric
+
+    @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/mcp_type_0.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="McpType0")
+
+
+@_attrs_define
+class McpType0:
+    """MCP configuration for the sandbox"""
+
+    additional_properties: dict[str, Any] = _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)
+        mcp_type_0 = cls()
+
+        mcp_type_0.additional_properties = d
+        return mcp_type_0
+
+    @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_access_token.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="NewAccessToken")
+
+
+@_attrs_define
+class NewAccessToken:
+    """
+    Attributes:
+        name (str): Name of the access token
+    """
+
+    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_access_token = cls(
+            name=name,
+        )
+
+        new_access_token.additional_properties = d
+        return new_access_token
+
+    @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