moru 0.1.0__py3-none-any.whl

moru/envd/process/process_pb2.pyi

@@ -0,0 +1,304 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import (
+    ClassVar as _ClassVar,
+    Iterable as _Iterable,
+    Mapping as _Mapping,
+    Optional as _Optional,
+    Union as _Union,
+)
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Signal(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    SIGNAL_UNSPECIFIED: _ClassVar[Signal]
+    SIGNAL_SIGTERM: _ClassVar[Signal]
+    SIGNAL_SIGKILL: _ClassVar[Signal]
+
+SIGNAL_UNSPECIFIED: Signal
+SIGNAL_SIGTERM: Signal
+SIGNAL_SIGKILL: Signal
+
+class PTY(_message.Message):
+    __slots__ = ("size",)
+    class Size(_message.Message):
+        __slots__ = ("cols", "rows")
+        COLS_FIELD_NUMBER: _ClassVar[int]
+        ROWS_FIELD_NUMBER: _ClassVar[int]
+        cols: int
+        rows: int
+        def __init__(
+            self, cols: _Optional[int] = ..., rows: _Optional[int] = ...
+        ) -> None: ...
+
+    SIZE_FIELD_NUMBER: _ClassVar[int]
+    size: PTY.Size
+    def __init__(self, size: _Optional[_Union[PTY.Size, _Mapping]] = ...) -> None: ...
+
+class ProcessConfig(_message.Message):
+    __slots__ = ("cmd", "args", "envs", "cwd")
+    class EnvsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(
+            self, key: _Optional[str] = ..., value: _Optional[str] = ...
+        ) -> None: ...
+
+    CMD_FIELD_NUMBER: _ClassVar[int]
+    ARGS_FIELD_NUMBER: _ClassVar[int]
+    ENVS_FIELD_NUMBER: _ClassVar[int]
+    CWD_FIELD_NUMBER: _ClassVar[int]
+    cmd: str
+    args: _containers.RepeatedScalarFieldContainer[str]
+    envs: _containers.ScalarMap[str, str]
+    cwd: str
+    def __init__(
+        self,
+        cmd: _Optional[str] = ...,
+        args: _Optional[_Iterable[str]] = ...,
+        envs: _Optional[_Mapping[str, str]] = ...,
+        cwd: _Optional[str] = ...,
+    ) -> None: ...
+
+class ListRequest(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class ProcessInfo(_message.Message):
+    __slots__ = ("config", "pid", "tag")
+    CONFIG_FIELD_NUMBER: _ClassVar[int]
+    PID_FIELD_NUMBER: _ClassVar[int]
+    TAG_FIELD_NUMBER: _ClassVar[int]
+    config: ProcessConfig
+    pid: int
+    tag: str
+    def __init__(
+        self,
+        config: _Optional[_Union[ProcessConfig, _Mapping]] = ...,
+        pid: _Optional[int] = ...,
+        tag: _Optional[str] = ...,
+    ) -> None: ...
+
+class ListResponse(_message.Message):
+    __slots__ = ("processes",)
+    PROCESSES_FIELD_NUMBER: _ClassVar[int]
+    processes: _containers.RepeatedCompositeFieldContainer[ProcessInfo]
+    def __init__(
+        self, processes: _Optional[_Iterable[_Union[ProcessInfo, _Mapping]]] = ...
+    ) -> None: ...
+
+class StartRequest(_message.Message):
+    __slots__ = ("process", "pty", "tag", "stdin")
+    PROCESS_FIELD_NUMBER: _ClassVar[int]
+    PTY_FIELD_NUMBER: _ClassVar[int]
+    TAG_FIELD_NUMBER: _ClassVar[int]
+    STDIN_FIELD_NUMBER: _ClassVar[int]
+    process: ProcessConfig
+    pty: PTY
+    tag: str
+    stdin: bool
+    def __init__(
+        self,
+        process: _Optional[_Union[ProcessConfig, _Mapping]] = ...,
+        pty: _Optional[_Union[PTY, _Mapping]] = ...,
+        tag: _Optional[str] = ...,
+        stdin: bool = ...,
+    ) -> None: ...
+
+class UpdateRequest(_message.Message):
+    __slots__ = ("process", "pty")
+    PROCESS_FIELD_NUMBER: _ClassVar[int]
+    PTY_FIELD_NUMBER: _ClassVar[int]
+    process: ProcessSelector
+    pty: PTY
+    def __init__(
+        self,
+        process: _Optional[_Union[ProcessSelector, _Mapping]] = ...,
+        pty: _Optional[_Union[PTY, _Mapping]] = ...,
+    ) -> None: ...
+
+class UpdateResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class ProcessEvent(_message.Message):
+    __slots__ = ("start", "data", "end", "keepalive")
+    class StartEvent(_message.Message):
+        __slots__ = ("pid",)
+        PID_FIELD_NUMBER: _ClassVar[int]
+        pid: int
+        def __init__(self, pid: _Optional[int] = ...) -> None: ...
+
+    class DataEvent(_message.Message):
+        __slots__ = ("stdout", "stderr", "pty")
+        STDOUT_FIELD_NUMBER: _ClassVar[int]
+        STDERR_FIELD_NUMBER: _ClassVar[int]
+        PTY_FIELD_NUMBER: _ClassVar[int]
+        stdout: bytes
+        stderr: bytes
+        pty: bytes
+        def __init__(
+            self,
+            stdout: _Optional[bytes] = ...,
+            stderr: _Optional[bytes] = ...,
+            pty: _Optional[bytes] = ...,
+        ) -> None: ...
+
+    class EndEvent(_message.Message):
+        __slots__ = ("exit_code", "exited", "status", "error")
+        EXIT_CODE_FIELD_NUMBER: _ClassVar[int]
+        EXITED_FIELD_NUMBER: _ClassVar[int]
+        STATUS_FIELD_NUMBER: _ClassVar[int]
+        ERROR_FIELD_NUMBER: _ClassVar[int]
+        exit_code: int
+        exited: bool
+        status: str
+        error: str
+        def __init__(
+            self,
+            exit_code: _Optional[int] = ...,
+            exited: bool = ...,
+            status: _Optional[str] = ...,
+            error: _Optional[str] = ...,
+        ) -> None: ...
+
+    class KeepAlive(_message.Message):
+        __slots__ = ()
+        def __init__(self) -> None: ...
+
+    START_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    END_FIELD_NUMBER: _ClassVar[int]
+    KEEPALIVE_FIELD_NUMBER: _ClassVar[int]
+    start: ProcessEvent.StartEvent
+    data: ProcessEvent.DataEvent
+    end: ProcessEvent.EndEvent
+    keepalive: ProcessEvent.KeepAlive
+    def __init__(
+        self,
+        start: _Optional[_Union[ProcessEvent.StartEvent, _Mapping]] = ...,
+        data: _Optional[_Union[ProcessEvent.DataEvent, _Mapping]] = ...,
+        end: _Optional[_Union[ProcessEvent.EndEvent, _Mapping]] = ...,
+        keepalive: _Optional[_Union[ProcessEvent.KeepAlive, _Mapping]] = ...,
+    ) -> None: ...
+
+class StartResponse(_message.Message):
+    __slots__ = ("event",)
+    EVENT_FIELD_NUMBER: _ClassVar[int]
+    event: ProcessEvent
+    def __init__(
+        self, event: _Optional[_Union[ProcessEvent, _Mapping]] = ...
+    ) -> None: ...
+
+class ConnectResponse(_message.Message):
+    __slots__ = ("event",)
+    EVENT_FIELD_NUMBER: _ClassVar[int]
+    event: ProcessEvent
+    def __init__(
+        self, event: _Optional[_Union[ProcessEvent, _Mapping]] = ...
+    ) -> None: ...
+
+class SendInputRequest(_message.Message):
+    __slots__ = ("process", "input")
+    PROCESS_FIELD_NUMBER: _ClassVar[int]
+    INPUT_FIELD_NUMBER: _ClassVar[int]
+    process: ProcessSelector
+    input: ProcessInput
+    def __init__(
+        self,
+        process: _Optional[_Union[ProcessSelector, _Mapping]] = ...,
+        input: _Optional[_Union[ProcessInput, _Mapping]] = ...,
+    ) -> None: ...
+
+class SendInputResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class ProcessInput(_message.Message):
+    __slots__ = ("stdin", "pty")
+    STDIN_FIELD_NUMBER: _ClassVar[int]
+    PTY_FIELD_NUMBER: _ClassVar[int]
+    stdin: bytes
+    pty: bytes
+    def __init__(
+        self, stdin: _Optional[bytes] = ..., pty: _Optional[bytes] = ...
+    ) -> None: ...
+
+class StreamInputRequest(_message.Message):
+    __slots__ = ("start", "data", "keepalive")
+    class StartEvent(_message.Message):
+        __slots__ = ("process",)
+        PROCESS_FIELD_NUMBER: _ClassVar[int]
+        process: ProcessSelector
+        def __init__(
+            self, process: _Optional[_Union[ProcessSelector, _Mapping]] = ...
+        ) -> None: ...
+
+    class DataEvent(_message.Message):
+        __slots__ = ("input",)
+        INPUT_FIELD_NUMBER: _ClassVar[int]
+        input: ProcessInput
+        def __init__(
+            self, input: _Optional[_Union[ProcessInput, _Mapping]] = ...
+        ) -> None: ...
+
+    class KeepAlive(_message.Message):
+        __slots__ = ()
+        def __init__(self) -> None: ...
+
+    START_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    KEEPALIVE_FIELD_NUMBER: _ClassVar[int]
+    start: StreamInputRequest.StartEvent
+    data: StreamInputRequest.DataEvent
+    keepalive: StreamInputRequest.KeepAlive
+    def __init__(
+        self,
+        start: _Optional[_Union[StreamInputRequest.StartEvent, _Mapping]] = ...,
+        data: _Optional[_Union[StreamInputRequest.DataEvent, _Mapping]] = ...,
+        keepalive: _Optional[_Union[StreamInputRequest.KeepAlive, _Mapping]] = ...,
+    ) -> None: ...
+
+class StreamInputResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class SendSignalRequest(_message.Message):
+    __slots__ = ("process", "signal")
+    PROCESS_FIELD_NUMBER: _ClassVar[int]
+    SIGNAL_FIELD_NUMBER: _ClassVar[int]
+    process: ProcessSelector
+    signal: Signal
+    def __init__(
+        self,
+        process: _Optional[_Union[ProcessSelector, _Mapping]] = ...,
+        signal: _Optional[_Union[Signal, str]] = ...,
+    ) -> None: ...
+
+class SendSignalResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class ConnectRequest(_message.Message):
+    __slots__ = ("process",)
+    PROCESS_FIELD_NUMBER: _ClassVar[int]
+    process: ProcessSelector
+    def __init__(
+        self, process: _Optional[_Union[ProcessSelector, _Mapping]] = ...
+    ) -> None: ...
+
+class ProcessSelector(_message.Message):
+    __slots__ = ("pid", "tag")
+    PID_FIELD_NUMBER: _ClassVar[int]
+    TAG_FIELD_NUMBER: _ClassVar[int]
+    pid: int
+    tag: str
+    def __init__(
+        self, pid: _Optional[int] = ..., tag: _Optional[str] = ...
+    ) -> None: ...

moru/envd/rpc.py

@@ -0,0 +1,61 @@
+import base64
+
+from typing import Optional
+from packaging.version import Version
+from moru_connect.client import Code, ConnectException
+
+from moru.exceptions import (
+    SandboxException,
+    InvalidArgumentException,
+    NotFoundException,
+    TimeoutException,
+    format_sandbox_timeout_exception,
+    AuthenticationException,
+    RateLimitException,
+)
+from moru.connection_config import Username, default_username
+from moru.envd.versions import ENVD_DEFAULT_USER
+
+
+def handle_rpc_exception(e: Exception):
+    if isinstance(e, ConnectException):
+        if e.status == Code.invalid_argument:
+            return InvalidArgumentException(e.message)
+        elif e.status == Code.unauthenticated:
+            return AuthenticationException(e.message)
+        elif e.status == Code.not_found:
+            return NotFoundException(e.message)
+        elif e.status == Code.unavailable:
+            return format_sandbox_timeout_exception(e.message)
+        elif e.status == Code.resource_exhausted:
+            return RateLimitException(
+                f"{e.message}: Rate limit exceeded, please try again later."
+            )
+        elif e.status == Code.canceled:
+            return TimeoutException(
+                f"{e.message}: This error is likely due to exceeding 'request_timeout'. You can pass the request timeout value as an option when making the request."
+            )
+        elif e.status == Code.deadline_exceeded:
+            return TimeoutException(
+                f"{e.message}: This error is likely due to exceeding 'timeout' — the total time a long running request (like process or directory watch) can be active. It can be modified by passing 'timeout' when making the request. Use '0' to disable the timeout."
+            )
+        else:
+            return SandboxException(f"{e.status}: {e.message}")
+    else:
+        return e
+
+
+def authentication_header(
+    envd_version: Version, user: Optional[Username] = None
+) -> dict[str, str]:
+    if user is None and envd_version < ENVD_DEFAULT_USER:
+        user = default_username
+
+    if not user:
+        return {}
+
+    value = f"{user}:"
+
+    encoded = base64.b64encode(value.encode("utf-8")).decode("utf-8")
+
+    return {"Authorization": f"Basic {encoded}"}

moru/envd/versions.py

@@ -0,0 +1,6 @@
+from packaging.version import Version
+
+ENVD_VERSION_RECURSIVE_WATCH = Version("0.1.4")
+ENVD_DEBUG_FALLBACK = Version("99.99.99")
+ENVD_COMMANDS_STDIN = Version("0.3.0")
+ENVD_DEFAULT_USER = Version("0.4.0")

moru/exceptions.py

@@ -0,0 +1,95 @@
+def format_sandbox_timeout_exception(message: str):
+    return TimeoutException(
+        f"{message}: This error is likely due to sandbox timeout. You can modify the sandbox timeout by passing 'timeout' when starting the sandbox or calling '.set_timeout' on the sandbox with the desired timeout."
+    )
+
+
+def format_request_timeout_error() -> Exception:
+    return TimeoutException(
+        "Request timed out — the 'request_timeout' option can be used to increase this timeout",
+    )
+
+
+def format_execution_timeout_error() -> Exception:
+    return TimeoutException(
+        "Execution timed out — the 'timeout' option can be used to increase this timeout",
+    )
+
+
+class SandboxException(Exception):
+    """
+    Base class for all sandbox errors.
+
+    Raised when a general sandbox exception occurs.
+    """
+
+    pass
+
+
+class TimeoutException(SandboxException):
+    """
+    Raised when a timeout occurs.
+
+    The `unavailable` exception type is caused by sandbox timeout.\n
+    The `canceled` exception type is caused by exceeding request timeout.\n
+    The `deadline_exceeded` exception type is caused by exceeding the timeout for process, watch, etc.\n
+    The `unknown` exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.\n
+    """
+
+    pass
+
+
+class InvalidArgumentException(SandboxException):
+    """
+    Raised when an invalid argument is provided.
+    """
+
+    pass
+
+
+class NotEnoughSpaceException(SandboxException):
+    """
+    Raised when there is not enough disk space.
+    """
+
+    pass
+
+
+class NotFoundException(SandboxException):
+    """
+    Raised when a resource is not found.
+    """
+
+    pass
+
+
+class AuthenticationException(Exception):
+    """
+    Raised when authentication fails.
+    """
+
+    pass
+
+
+class TemplateException(SandboxException):
+    """
+    Exception raised when the template uses old envd version. It isn't compatible with the new SDK.
+    """
+
+
+class RateLimitException(SandboxException):
+    """
+    Raised when the API rate limit is exceeded.
+    """
+
+
+class BuildException(Exception):
+    """
+    Raised when the build fails.
+    """
+
+
+class FileUploadException(BuildException):
+    """
+    Raised when the file upload fails.
+    """

moru/sandbox/commands/command_handle.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from moru.exceptions import SandboxException
+
+Stdout = str
+"""
+Command stdout output.
+"""
+Stderr = str
+"""
+Command stderr output.
+"""
+PtyOutput = bytes
+"""
+Pty output.
+"""
+
+
+@dataclass
+class PtySize:
+    """
+    Pseudo-terminal size.
+    """
+
+    rows: int
+    """
+    Number of rows.
+    """
+    cols: int
+    """
+    Number of columns.
+    """
+
+
+@dataclass
+class CommandResult:
+    """
+    Command execution result.
+    """
+
+    stderr: str
+    """
+    Command stderr output.
+    """
+    stdout: str
+    """
+    Command stdout output.
+    """
+    exit_code: int
+    """
+    Command exit code.
+
+    `0` if the command finished successfully.
+    """
+    error: Optional[str]
+    """
+    Error message from command execution if it failed.
+    """
+
+
+@dataclass
+class CommandExitException(SandboxException, CommandResult):
+    """
+    Exception raised when a command exits with a non-zero exit code.
+    """
+
+    def __str__(self):
+        return f"Command exited with code {self.exit_code} and error:\n{self.stderr}"

moru/sandbox/commands/main.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass
+class ProcessInfo:
+    """
+    Information about a command, PTY session or start command running in the sandbox as process.
+    """
+
+    pid: int
+    """
+    Process ID.
+    """
+
+    tag: Optional[str]
+    """
+    Custom tag used for identifying special commands like start command in the custom template.
+    """
+
+    cmd: str
+    """
+    Command that was executed.
+    """
+
+    args: List[str]
+    """
+    Command arguments.
+    """
+
+    envs: Dict[str, str]
+    """
+    Environment variables used for the command.
+    """
+
+    cwd: Optional[str]
+    """
+    Executed command working directory.
+    """

moru/sandbox/filesystem/filesystem.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import IO, Optional, Union, TypedDict
+
+from moru.envd.filesystem import filesystem_pb2
+
+
+class FileType(Enum):
+    """
+    Enum representing the type of filesystem object.
+    """
+
+    FILE = "file"
+    """
+    Filesystem object is a file.
+    """
+    DIR = "dir"
+    """
+    Filesystem object is a directory.
+    """
+
+
+def map_file_type(ft: filesystem_pb2.FileType):
+    if ft == filesystem_pb2.FileType.FILE_TYPE_FILE:
+        return FileType.FILE
+    elif ft == filesystem_pb2.FileType.FILE_TYPE_DIRECTORY:
+        return FileType.DIR
+
+
+@dataclass
+class WriteInfo:
+    """
+    Sandbox filesystem object information.
+    """
+
+    name: str
+    """
+    Name of the filesystem object.
+    """
+    type: Optional[FileType]
+    """
+    Type of the filesystem object.
+    """
+    path: str
+    """
+    Path to the filesystem object.
+    """
+
+
+@dataclass
+class EntryInfo(WriteInfo):
+    """
+    Extended sandbox filesystem object information.
+    """
+
+    size: int
+    """
+    Size of the filesystem object in bytes.
+    """
+    mode: int
+    """
+    File mode and permission bits.
+    """
+    permissions: str
+    """
+    String representation of file permissions (e.g. 'rwxr-xr-x').
+    """
+    owner: str
+    """
+    Owner of the filesystem object.
+    """
+    group: str
+    """
+    Group owner of the filesystem object.
+    """
+    modified_time: datetime
+    """
+    Last modification time of the filesystem object.
+    """
+    symlink_target: Optional[str] = None
+    """
+    Target of the symlink if the filesystem object is a symlink.
+    If the filesystem object is not a symlink, this field is None.
+    """
+
+
+class WriteEntry(TypedDict):
+    """
+    Contains path and data of the file to be written to the filesystem.
+    """
+
+    path: str
+    data: Union[str, bytes, IO]