moru 0.1.0__py3-none-any.whl

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

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

moru/api/client/models/created_access_token.py

@@ -0,0 +1,100 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.identifier_masking_details import IdentifierMaskingDetails
+
+
+T = TypeVar("T", bound="CreatedAccessToken")
+
+
+@_attrs_define
+class CreatedAccessToken:
+    """
+    Attributes:
+        created_at (datetime.datetime): Timestamp of access token creation
+        id (UUID): Identifier of the access token
+        mask (IdentifierMaskingDetails):
+        name (str): Name of the access token
+        token (str): The fully created access token
+    """
+
+    created_at: datetime.datetime
+    id: UUID
+    mask: "IdentifierMaskingDetails"
+    name: str
+    token: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        id = str(self.id)
+
+        mask = self.mask.to_dict()
+
+        name = self.name
+
+        token = self.token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "id": id,
+                "mask": mask,
+                "name": name,
+                "token": token,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.identifier_masking_details import IdentifierMaskingDetails
+
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        id = UUID(d.pop("id"))
+
+        mask = IdentifierMaskingDetails.from_dict(d.pop("mask"))
+
+        name = d.pop("name")
+
+        token = d.pop("token")
+
+        created_access_token = cls(
+            created_at=created_at,
+            id=id,
+            mask=mask,
+            name=name,
+            token=token,
+        )
+
+        created_access_token.additional_properties = d
+        return created_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

moru/api/client/models/created_team_api_key.py

@@ -0,0 +1,166 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.identifier_masking_details import IdentifierMaskingDetails
+    from ..models.team_user import TeamUser
+
+
+T = TypeVar("T", bound="CreatedTeamAPIKey")
+
+
+@_attrs_define
+class CreatedTeamAPIKey:
+    """
+    Attributes:
+        created_at (datetime.datetime): Timestamp of API key creation
+        id (UUID): Identifier of the API key
+        key (str): Raw value of the API key
+        mask (IdentifierMaskingDetails):
+        name (str): Name of the API key
+        created_by (Union['TeamUser', None, Unset]):
+        last_used (Union[None, Unset, datetime.datetime]): Last time this API key was used
+    """
+
+    created_at: datetime.datetime
+    id: UUID
+    key: str
+    mask: "IdentifierMaskingDetails"
+    name: str
+    created_by: Union["TeamUser", None, Unset] = UNSET
+    last_used: Union[None, Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.team_user import TeamUser
+
+        created_at = self.created_at.isoformat()
+
+        id = str(self.id)
+
+        key = self.key
+
+        mask = self.mask.to_dict()
+
+        name = self.name
+
+        created_by: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.created_by, Unset):
+            created_by = UNSET
+        elif isinstance(self.created_by, TeamUser):
+            created_by = self.created_by.to_dict()
+        else:
+            created_by = self.created_by
+
+        last_used: Union[None, Unset, str]
+        if isinstance(self.last_used, Unset):
+            last_used = UNSET
+        elif isinstance(self.last_used, datetime.datetime):
+            last_used = self.last_used.isoformat()
+        else:
+            last_used = self.last_used
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "createdAt": created_at,
+                "id": id,
+                "key": key,
+                "mask": mask,
+                "name": name,
+            }
+        )
+        if created_by is not UNSET:
+            field_dict["createdBy"] = created_by
+        if last_used is not UNSET:
+            field_dict["lastUsed"] = last_used
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.identifier_masking_details import IdentifierMaskingDetails
+        from ..models.team_user import TeamUser
+
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("createdAt"))
+
+        id = UUID(d.pop("id"))
+
+        key = d.pop("key")
+
+        mask = IdentifierMaskingDetails.from_dict(d.pop("mask"))
+
+        name = d.pop("name")
+
+        def _parse_created_by(data: object) -> Union["TeamUser", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                created_by_type_1 = TeamUser.from_dict(data)
+
+                return created_by_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union["TeamUser", None, Unset], data)
+
+        created_by = _parse_created_by(d.pop("createdBy", UNSET))
+
+        def _parse_last_used(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_used_type_0 = isoparse(data)
+
+                return last_used_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        last_used = _parse_last_used(d.pop("lastUsed", UNSET))
+
+        created_team_api_key = cls(
+            created_at=created_at,
+            id=id,
+            key=key,
+            mask=mask,
+            name=name,
+            created_by=created_by,
+            last_used=last_used,
+        )
+
+        created_team_api_key.additional_properties = d
+        return created_team_api_key
+
+    @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/disk_metrics.py

@@ -0,0 +1,91 @@
+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="DiskMetrics")
+
+
+@_attrs_define
+class DiskMetrics:
+    """
+    Attributes:
+        device (str): Device name
+        filesystem_type (str): Filesystem type (e.g., ext4, xfs)
+        mount_point (str): Mount point of the disk
+        total_bytes (int): Total space in bytes
+        used_bytes (int): Used space in bytes
+    """
+
+    device: str
+    filesystem_type: str
+    mount_point: str
+    total_bytes: int
+    used_bytes: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        device = self.device
+
+        filesystem_type = self.filesystem_type
+
+        mount_point = self.mount_point
+
+        total_bytes = self.total_bytes
+
+        used_bytes = self.used_bytes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "device": device,
+                "filesystemType": filesystem_type,
+                "mountPoint": mount_point,
+                "totalBytes": total_bytes,
+                "usedBytes": used_bytes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        device = d.pop("device")
+
+        filesystem_type = d.pop("filesystemType")
+
+        mount_point = d.pop("mountPoint")
+
+        total_bytes = d.pop("totalBytes")
+
+        used_bytes = d.pop("usedBytes")
+
+        disk_metrics = cls(
+            device=device,
+            filesystem_type=filesystem_type,
+            mount_point=mount_point,
+            total_bytes=total_bytes,
+            used_bytes=used_bytes,
+        )
+
+        disk_metrics.additional_properties = d
+        return disk_metrics
+
+    @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/error.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="Error")
+
+
+@_attrs_define
+class Error:
+    """
+    Attributes:
+        code (int): Error code
+        message (str): Error
+    """
+
+    code: int
+    message: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        message = d.pop("message")
+
+        error = cls(
+            code=code,
+            message=message,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @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/gcp_registry.py

@@ -0,0 +1,69 @@
+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.gcp_registry_type import GCPRegistryType
+
+T = TypeVar("T", bound="GCPRegistry")
+
+
+@_attrs_define
+class GCPRegistry:
+    """
+    Attributes:
+        service_account_json (str): Service Account JSON for GCP authentication
+        type_ (GCPRegistryType): Type of registry authentication
+    """
+
+    service_account_json: str
+    type_: GCPRegistryType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        service_account_json = self.service_account_json
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "serviceAccountJson": service_account_json,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        service_account_json = d.pop("serviceAccountJson")
+
+        type_ = GCPRegistryType(d.pop("type"))
+
+        gcp_registry = cls(
+            service_account_json=service_account_json,
+            type_=type_,
+        )
+
+        gcp_registry.additional_properties = d
+        return gcp_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

moru/api/client/models/gcp_registry_type.py

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