loopix-sdk 2.30.0__py3-none-any.whl

loopix/api/client/models/admin_build_cancel_result.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="AdminBuildCancelResult")
+
+
+@_attrs_define
+class AdminBuildCancelResult:
+    """
+    Attributes:
+        cancelled_count (int): Number of builds successfully cancelled
+        failed_count (int): Number of builds that failed to cancel
+    """
+
+    cancelled_count: int
+    failed_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cancelled_count = self.cancelled_count
+
+        failed_count = self.failed_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cancelledCount": cancelled_count,
+                "failedCount": failed_count,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cancelled_count = d.pop("cancelledCount")
+
+        failed_count = d.pop("failedCount")
+
+        admin_build_cancel_result = cls(
+            cancelled_count=cancelled_count,
+            failed_count=failed_count,
+        )
+
+        admin_build_cancel_result.additional_properties = d
+        return admin_build_cancel_result
+
+    @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/admin_sandbox_kill_result.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="AdminSandboxKillResult")
+
+
+@_attrs_define
+class AdminSandboxKillResult:
+    """
+    Attributes:
+        failed_count (int): Number of sandboxes that failed to kill
+        killed_count (int): Number of sandboxes successfully killed
+    """
+
+    failed_count: int
+    killed_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        failed_count = self.failed_count
+
+        killed_count = self.killed_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "failedCount": failed_count,
+                "killedCount": killed_count,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        failed_count = d.pop("failedCount")
+
+        killed_count = d.pop("killedCount")
+
+        admin_sandbox_kill_result = cls(
+            failed_count=failed_count,
+            killed_count=killed_count,
+        )
+
+        admin_sandbox_kill_result.additional_properties = d
+        return admin_sandbox_kill_result
+
+    @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/assign_template_tags_request.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AssignTemplateTagsRequest")
+
+
+@_attrs_define
+class AssignTemplateTagsRequest:
+    """
+    Attributes:
+        tags (list[str]): Tags to assign to the template
+        target (str): Target template in "name:tag" format
+    """
+
+    tags: list[str]
+    target: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tags = self.tags
+
+        target = self.target
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tags": tags,
+                "target": target,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        tags = cast(list[str], d.pop("tags"))
+
+        target = d.pop("target")
+
+        assign_template_tags_request = cls(
+            tags=tags,
+            target=target,
+        )
+
+        assign_template_tags_request.additional_properties = d
+        return assign_template_tags_request
+
+    @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/assigned_template_tags.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AssignedTemplateTags")
+
+
+@_attrs_define
+class AssignedTemplateTags:
+    """
+    Attributes:
+        build_id (UUID): Identifier of the build associated with these tags
+        tags (list[str]): Assigned tags of the template
+    """
+
+    build_id: UUID
+    tags: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        build_id = str(self.build_id)
+
+        tags = self.tags
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "buildID": build_id,
+                "tags": tags,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        build_id = UUID(d.pop("buildID"))
+
+        tags = cast(list[str], d.pop("tags"))
+
+        assigned_template_tags = cls(
+            build_id=build_id,
+            tags=tags,
+        )
+
+        assigned_template_tags.additional_properties = d
+        return assigned_template_tags
+
+    @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/aws_registry.py

@@ -0,0 +1,85 @@
+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.aws_registry_type import AWSRegistryType
+
+T = TypeVar("T", bound="AWSRegistry")
+
+
+@_attrs_define
+class AWSRegistry:
+    """
+    Attributes:
+        aws_access_key_id (str): AWS Access Key ID for ECR authentication
+        aws_region (str): AWS Region where the ECR registry is located
+        aws_secret_access_key (str): AWS Secret Access Key for ECR authentication
+        type_ (AWSRegistryType): Type of registry authentication
+    """
+
+    aws_access_key_id: str
+    aws_region: str
+    aws_secret_access_key: str
+    type_: AWSRegistryType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        aws_access_key_id = self.aws_access_key_id
+
+        aws_region = self.aws_region
+
+        aws_secret_access_key = self.aws_secret_access_key
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "awsAccessKeyId": aws_access_key_id,
+                "awsRegion": aws_region,
+                "awsSecretAccessKey": aws_secret_access_key,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        aws_access_key_id = d.pop("awsAccessKeyId")
+
+        aws_region = d.pop("awsRegion")
+
+        aws_secret_access_key = d.pop("awsSecretAccessKey")
+
+        type_ = AWSRegistryType(d.pop("type"))
+
+        aws_registry = cls(
+            aws_access_key_id=aws_access_key_id,
+            aws_region=aws_region,
+            aws_secret_access_key=aws_secret_access_key,
+            type_=type_,
+        )
+
+        aws_registry.additional_properties = d
+        return aws_registry
+
+    @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/aws_registry_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class AWSRegistryType(str, Enum):
+    AWS = "aws"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/build_log_entry.py

@@ -0,0 +1,89 @@
+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.log_level import LogLevel
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BuildLogEntry")
+
+
+@_attrs_define
+class BuildLogEntry:
+    """
+    Attributes:
+        level (LogLevel): State of the sandbox
+        message (str): Log message content
+        timestamp (datetime.datetime): Timestamp of the log entry
+        step (Union[Unset, str]): Step in the build process related to the log entry
+    """
+
+    level: LogLevel
+    message: str
+    timestamp: datetime.datetime
+    step: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        level = self.level.value
+
+        message = self.message
+
+        timestamp = self.timestamp.isoformat()
+
+        step = self.step
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "level": level,
+                "message": message,
+                "timestamp": timestamp,
+            }
+        )
+        if step is not UNSET:
+            field_dict["step"] = step
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        level = LogLevel(d.pop("level"))
+
+        message = d.pop("message")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        step = d.pop("step", UNSET)
+
+        build_log_entry = cls(
+            level=level,
+            message=message,
+            timestamp=timestamp,
+            step=step,
+        )
+
+        build_log_entry.additional_properties = d
+        return build_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/build_status_reason.py

@@ -0,0 +1,95 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.build_log_entry import BuildLogEntry
+
+
+T = TypeVar("T", bound="BuildStatusReason")
+
+
+@_attrs_define
+class BuildStatusReason:
+    """
+    Attributes:
+        message (str): Message with the status reason, currently reporting only for error status
+        log_entries (Union[Unset, list['BuildLogEntry']]): Log entries related to the status reason
+        step (Union[Unset, str]): Step that failed
+    """
+
+    message: str
+    log_entries: Union[Unset, list["BuildLogEntry"]] = UNSET
+    step: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        log_entries: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.log_entries, Unset):
+            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)
+
+        step = self.step
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "message": message,
+            }
+        )
+        if log_entries is not UNSET:
+            field_dict["logEntries"] = log_entries
+        if step is not UNSET:
+            field_dict["step"] = step
+
+        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)
+        message = d.pop("message")
+
+        log_entries = []
+        _log_entries = d.pop("logEntries", UNSET)
+        for log_entries_item_data in _log_entries or []:
+            log_entries_item = BuildLogEntry.from_dict(log_entries_item_data)
+
+            log_entries.append(log_entries_item)
+
+        step = d.pop("step", UNSET)
+
+        build_status_reason = cls(
+            message=message,
+            log_entries=log_entries,
+            step=step,
+        )
+
+        build_status_reason.additional_properties = d
+        return build_status_reason
+
+    @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/connect_sandbox.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="ConnectSandbox")
+
+
+@_attrs_define
+class ConnectSandbox:
+    """
+    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")
+
+        connect_sandbox = cls(
+            timeout=timeout,
+        )
+
+        connect_sandbox.additional_properties = d
+        return connect_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