moru 0.1.0__py3-none-any.whl

moru/api/client/models/general_registry.py

@@ -0,0 +1,77 @@
+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.general_registry_type import GeneralRegistryType
+
+T = TypeVar("T", bound="GeneralRegistry")
+
+
+@_attrs_define
+class GeneralRegistry:
+    """
+    Attributes:
+        password (str): Password to use for the registry
+        type_ (GeneralRegistryType): Type of registry authentication
+        username (str): Username to use for the registry
+    """
+
+    password: str
+    type_: GeneralRegistryType
+    username: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        password = self.password
+
+        type_ = self.type_.value
+
+        username = self.username
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "password": password,
+                "type": type_,
+                "username": username,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        password = d.pop("password")
+
+        type_ = GeneralRegistryType(d.pop("type"))
+
+        username = d.pop("username")
+
+        general_registry = cls(
+            password=password,
+            type_=type_,
+            username=username,
+        )
+
+        general_registry.additional_properties = d
+        return general_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/general_registry_type.py

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

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

moru/api/client/models/listed_sandbox.py

@@ -0,0 +1,154 @@
+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_state import SandboxState
+from ..types import UNSET, Unset
+
+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]):
+    """
+
+    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
+    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
+
+        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
+
+        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)
+
+        metadata = d.pop("metadata", UNSET)
+
+        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,
+        )
+
+        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

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

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

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

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

moru/api/client/models/new_sandbox.py

@@ -0,0 +1,172 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.mcp_type_0 import McpType0
+    from ..models.sandbox_network_config import SandboxNetworkConfig
+
+
+T = TypeVar("T", bound="NewSandbox")
+
+
+@_attrs_define
+class NewSandbox:
+    """
+    Attributes:
+        template_id (str): Identifier of the required template
+        allow_internet_access (Union[Unset, bool]): Allow sandbox to access the internet. When set to false, it behaves
+            the same as specifying denyOut to 0.0.0.0/0 in the network config.
+        auto_pause (Union[Unset, bool]): Automatically pauses the sandbox after the timeout Default: False.
+        env_vars (Union[Unset, Any]):
+        mcp (Union['McpType0', None, Unset]): MCP configuration for the sandbox
+        metadata (Union[Unset, Any]):
+        network (Union[Unset, SandboxNetworkConfig]):
+        secure (Union[Unset, bool]): Secure all system communication with sandbox
+        timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
+    """
+
+    template_id: str
+    allow_internet_access: Union[Unset, bool] = UNSET
+    auto_pause: Union[Unset, bool] = False
+    env_vars: Union[Unset, Any] = UNSET
+    mcp: Union["McpType0", None, Unset] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    network: Union[Unset, "SandboxNetworkConfig"] = UNSET
+    secure: 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]:
+        from ..models.mcp_type_0 import McpType0
+
+        template_id = self.template_id
+
+        allow_internet_access = self.allow_internet_access
+
+        auto_pause = self.auto_pause
+
+        env_vars = self.env_vars
+
+        mcp: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.mcp, Unset):
+            mcp = UNSET
+        elif isinstance(self.mcp, McpType0):
+            mcp = self.mcp.to_dict()
+        else:
+            mcp = self.mcp
+
+        metadata = self.metadata
+
+        network: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.network, Unset):
+            network = self.network.to_dict()
+
+        secure = self.secure
+
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "templateID": template_id,
+            }
+        )
+        if allow_internet_access is not UNSET:
+            field_dict["allow_internet_access"] = allow_internet_access
+        if auto_pause is not UNSET:
+            field_dict["autoPause"] = auto_pause
+        if env_vars is not UNSET:
+            field_dict["envVars"] = env_vars
+        if mcp is not UNSET:
+            field_dict["mcp"] = mcp
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if network is not UNSET:
+            field_dict["network"] = network
+        if secure is not UNSET:
+            field_dict["secure"] = secure
+        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:
+        from ..models.mcp_type_0 import McpType0
+        from ..models.sandbox_network_config import SandboxNetworkConfig
+
+        d = dict(src_dict)
+        template_id = d.pop("templateID")
+
+        allow_internet_access = d.pop("allow_internet_access", UNSET)
+
+        auto_pause = d.pop("autoPause", UNSET)
+
+        env_vars = d.pop("envVars", UNSET)
+
+        def _parse_mcp(data: object) -> Union["McpType0", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_mcp_type_0 = McpType0.from_dict(data)
+
+                return componentsschemas_mcp_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["McpType0", None, Unset], data)
+
+        mcp = _parse_mcp(d.pop("mcp", UNSET))
+
+        metadata = d.pop("metadata", UNSET)
+
+        _network = d.pop("network", UNSET)
+        network: Union[Unset, SandboxNetworkConfig]
+        if isinstance(_network, Unset):
+            network = UNSET
+        else:
+            network = SandboxNetworkConfig.from_dict(_network)
+
+        secure = d.pop("secure", UNSET)
+
+        timeout = d.pop("timeout", UNSET)
+
+        new_sandbox = cls(
+            template_id=template_id,
+            allow_internet_access=allow_internet_access,
+            auto_pause=auto_pause,
+            env_vars=env_vars,
+            mcp=mcp,
+            metadata=metadata,
+            network=network,
+            secure=secure,
+            timeout=timeout,
+        )
+
+        new_sandbox.additional_properties = d
+        return new_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