scalebox-sdk 0.1.25__py3-none-any.whl → 1.0.1__py3-none-any.whl

scalebox/generated/rpc.py

@@ -1,50 +1,50 @@
-import base64
-from typing import Optional
-
-from ..connection_config import Username, default_username
-from ..csx_connect.client import Code, ConnectException
-from ..exceptions import (
-    AuthenticationException,
-    InvalidArgumentException,
-    NotFoundException,
-    RateLimitException,
-    SandboxException,
-    TimeoutException,
-    sandbox_timeout_exception,
-)
-
-
-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 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(user: Optional[Username] = None):
-    value = f"{user if user is not None else default_username}:"
-
-    encoded = base64.b64encode(value.encode("utf-8")).decode("utf-8")
-
-    return {"Authorization": f"Basic {encoded}"}
+import base64
+from typing import Optional
+
+from ..connection_config import Username, default_username
+from ..csx_connect.client import Code, ConnectException
+from ..exceptions import (
+    AuthenticationException,
+    InvalidArgumentException,
+    NotFoundException,
+    RateLimitException,
+    SandboxException,
+    TimeoutException,
+    sandbox_timeout_exception,
+)
+
+
+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 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(user: Optional[Username] = None):
+    value = f"{user if user is not None else default_username}:"
+
+    encoded = base64.b64encode(value.encode("utf-8")).decode("utf-8")
+
+    return {"Authorization": f"Basic {encoded}"}

scalebox/sandbox/main.py

@@ -1,139 +1,146 @@
-import urllib.parse
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from httpx import Limits
-
-from ..connection_config import ConnectionConfig
-from ..generated.api import ENVD_API_FILES_ROUTE
-from .signature import get_signature
-
-
-class SandboxSetup(ABC):
-    _limits = Limits(
-        max_keepalive_connections=40,
-        max_connections=40,
-        keepalive_expiry=300,
-    )
-
-    envd_port = 443
-
-    default_sandbox_timeout = 300
-    default_template = "base"
-
-    @property
-    @abstractmethod
-    def connection_config(self) -> ConnectionConfig: ...
-
-    @property
-    @abstractmethod
-    def _envd_access_token(self) -> Optional[str]: ...
-
-    @property
-    @abstractmethod
-    def envd_api_url(self) -> str: ...
-
-    @property
-    @abstractmethod
-    def sandbox_id(self) -> str: ...
-
-    @property
-    @abstractmethod
-    def sandbox_domain(self) -> str: ...
-
-    def _file_url(
-        self,
-        path: Optional[str] = None,
-        user: str = "user",
-        signature: Optional[str] = None,
-        signature_expiration: Optional[int] = None,
-    ) -> str:
-        url = urllib.parse.urljoin(self.envd_api_url, ENVD_API_FILES_ROUTE)
-        query = {"path": path} if path else {}
-        query = {**query, "username": user}
-
-        if signature:
-            query["signature"] = signature
-
-        if signature_expiration:
-            if signature is None:
-                raise ValueError("signature_expiration requires signature to be set")
-            query["signature_expiration"] = str(signature_expiration)
-
-        params = urllib.parse.urlencode(
-            query,
-            quote_via=urllib.parse.quote,
-        )
-        url = urllib.parse.urljoin(url, f"?{params}")
-
-        return url
-
-    def download_url(
-        self,
-        path: str,
-        user: str = "user",
-        use_signature_expiration: Optional[int] = None,
-    ) -> str:
-        """
-        Get the URL to download a file from the sandbox.
-
-        :param path: Path to the file to download
-        :param user: User to upload the file as
-        :param use_signature_expiration: Expiration time for the signed URL in seconds
-
-        :return: URL for downloading file
-        """
-
-        use_signature = self._envd_access_token is not None
-        if use_signature:
-            signature = get_signature(
-                path, "read", user, self._envd_access_token, use_signature_expiration
-            )
-            return self._file_url(
-                path, user, signature["signature"], signature["expiration"]
-            )
-        else:
-            return self._file_url(path)
-
-    def upload_url(
-        self,
-        path: Optional[str] = None,
-        user: str = "user",
-        use_signature_expiration: Optional[int] = None,
-    ) -> str:
-        """
-        Get the URL to upload a file to the sandbox.
-
-        You have to send a POST request to this URL with the file as multipart/form-data.
-
-        :param path: Path to the file to upload
-        :param user: User to upload the file as
-        :param use_signature_expiration: Expiration time for the signed URL in seconds
-
-        :return: URL for uploading file
-        """
-
-        use_signature = self._envd_access_token is not None
-        if use_signature:
-            signature = get_signature(
-                path, "write", user, self._envd_access_token, use_signature_expiration
-            )
-            return self._file_url(
-                path, user, signature["signature"], signature["expiration"]
-            )
-        else:
-            return self._file_url(path)
-
-    def get_host(self, port: int) -> str:
-        """
-        Get the host address to connect to the sandbox.
-        You can then use this address to connect to the sandbox port from outside the sandbox via HTTP or WebSocket.
-
-        :param port: Port to connect to
-
-        :return: Host address to connect to
-        """
-        if self.connection_config.debug:
-            return f"localhost:{port}"
-        return f"{self.sandbox_domain}"
-        # return f"{port}-{self.sandbox_id}.{self.sandbox_domain}"
+import urllib.parse
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from httpx import Limits
+
+from ..connection_config import ConnectionConfig
+from ..generated.api import ENVD_API_DOWNLOAD_FILES_ROUTE,ENVD_API_UPLOAD_FILES_ROUTE
+from .signature import get_signature, Operation
+
+
+class SandboxSetup(ABC):
+    _limits = Limits(
+        max_keepalive_connections=40,
+        max_connections=40,
+        keepalive_expiry=300,
+    )
+
+    envd_port = 443
+
+    default_sandbox_timeout = 300
+    default_template = "base"
+
+    @property
+    @abstractmethod
+    def connection_config(self) -> ConnectionConfig: ...
+
+    @property
+    @abstractmethod
+    def _envd_access_token(self) -> Optional[str]: ...
+
+    @property
+    @abstractmethod
+    def envd_api_url(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def sandbox_id(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def sandbox_domain(self) -> str: ...
+
+    def _file_url(
+        self,
+        path: Optional[str] = None,
+        operation: Operation = "read",
+        user: str = "root",
+        signature: Optional[str] = None,
+        signature_expiration: Optional[int] = None,
+    ) -> str:
+        query = {}
+        url = urllib.parse.urljoin(self.envd_api_url, ENVD_API_DOWNLOAD_FILES_ROUTE)
+        if operation == "write":
+            url = urllib.parse.urljoin(self.envd_api_url, ENVD_API_UPLOAD_FILES_ROUTE)
+            query = {**query,"path": path}
+        else:
+            url = f"{url}/{path.lstrip('/')}"
+        query = {**query, "username": user}
+
+        if signature:
+            query["signature"] = signature
+
+        if signature_expiration:
+            if signature is None:
+                raise ValueError("signature_expiration requires signature to be set")
+            query["signature_expiration"] = str(signature_expiration)
+
+        params = urllib.parse.urlencode(
+            query,
+            quote_via=urllib.parse.quote,
+        )
+        url = urllib.parse.urljoin(url, f"?{params}")
+
+        return url
+
+    def download_url(
+        self,
+        path: str,
+        user: str = "root",
+        use_signature_expiration: Optional[int] = None,
+    ) -> str:
+        """
+        Get the URL to download a file from the sandbox.
+
+        :param path: Path to the file to download
+        :param user: User to upload the file as
+        :param use_signature_expiration: Expiration time for the signed URL in seconds
+
+        :return: URL for downloading file
+        """
+
+        use_signature = self._envd_access_token is not None
+        if use_signature:
+            signature = get_signature(
+                path, "read", user, self._envd_access_token, use_signature_expiration
+            )
+            return self._file_url(
+                path,"read", user, signature["signature"], signature["expiration"]
+            )
+        else:
+            return self._file_url(path)
+
+    def upload_url(
+        self,
+        path: Optional[str] = None,
+        user: str = "root",
+        use_signature_expiration: Optional[int] = None,
+    ) -> str:
+        """
+        Get the URL to upload a file to the sandbox.
+
+        You have to send a POST request to this URL with the file as multipart/form-data.
+
+        :param path: Path to the file to upload
+        :param user: User to upload the file as
+        :param use_signature_expiration: Expiration time for the signed URL in seconds
+
+        :return: URL for uploading file
+        """
+
+        use_signature = self._envd_access_token is not None
+        if use_signature:
+            signature = get_signature(
+                path, "write", user, self._envd_access_token, use_signature_expiration
+            )
+            return self._file_url(
+                path,"write", user, signature["signature"], signature["expiration"]
+            )
+        else:
+            return self._file_url(path)
+
+    def get_host(self, port: int) -> str:
+        """
+        Get the host address to connect to the sandbox.
+        You can then use this address to connect to the sandbox port from outside the sandbox via HTTP or WebSocket.
+
+        :param port: Port to connect to
+
+        :return: Host address to connect to
+        """
+        if self.connection_config.debug:
+            debug_host = self.connection_config.debug_host
+            return f"{debug_host}:{port}"
+        return f"{self.sandbox_domain}"
+        # return f"{port}-{self.sandbox_id}.{self.sandbox_domain}"

scalebox/sandbox/sandbox_api.py

@@ -1,91 +1,105 @@
-from abc import ABC
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Dict, Optional
-
-from httpx import Limits
-
-from ..api.client.models import SandboxState
-
-
-@dataclass
-class SandboxInfo:
-    """Information about a sandbox."""
-
-    sandbox_id: str
-    """Sandbox ID."""
-    sandbox_domain: Optional[str]
-    """Domain where the sandbox is hosted."""
-    template_id: str
-    """Template ID."""
-    name: Optional[str]
-    """Template name."""
-    metadata: Dict[str, str]
-    """Saved sandbox metadata."""
-    started_at: datetime
-    """Sandbox start time."""
-    end_at: datetime
-    """Sandbox expiration date."""
-    envd_version: Optional[str]
-    """Envd version."""
-    _envd_access_token: Optional[str]
-    """Envd access token."""
-
-
-@dataclass
-class ListedSandbox:
-    """Information about a sandbox."""
-
-    sandbox_id: str
-    """Sandbox ID."""
-    template_id: str
-    """Template ID."""
-    name: Optional[str]
-    """Template Alias."""
-    state: SandboxState
-    """Sandbox state."""
-    cpu_count: int
-    """Sandbox CPU count."""
-    memory_mb: int
-    """Sandbox Memory size in MB."""
-    metadata: Dict[str, str]
-    """Saved sandbox metadata."""
-    started_at: datetime
-    """Sandbox start time."""
-    end_at: datetime
-
-
-@dataclass
-class SandboxQuery:
-    """Query parameters for listing sandboxes."""
-
-    metadata: Optional[dict[str, str]] = None
-    """Filter sandboxes by metadata."""
-
-
-@dataclass
-class SandboxMetrics:
-    """Sandbox metrics."""
-
-    cpu_count: int
-    """Number of CPUs."""
-    cpu_used_pct: float
-    """CPU usage percentage."""
-    disk_total: int
-    """Total disk space in bytes."""
-    disk_used: int
-    """Disk used in bytes."""
-    mem_total: int
-    """Total memory in bytes."""
-    mem_used: int
-    """Memory used in bytes."""
-    timestamp: datetime
-    """Timestamp of the metric entry."""
-
-
-class SandboxApiBase(ABC):
-    _limits = Limits(
-        max_keepalive_connections=10,
-        max_connections=20,
-        keepalive_expiry=20,
-    )
+from abc import ABC
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, Optional
+
+from httpx import Limits
+
+from ..api.client.models import SandboxState
+
+
+@dataclass
+class SandboxInfo:
+    """Information about a sandbox."""
+
+    sandbox_id: str
+    """Sandbox ID."""
+    sandbox_domain: Optional[str]
+    """Domain where the sandbox is hosted."""
+    template_id: str
+    """Template ID."""
+    name: Optional[str]
+    """Template name."""
+    metadata: Dict[str, str]
+    """Saved sandbox metadata."""
+    started_at: datetime
+    """Sandbox start time."""
+    uptime: int
+    """Sandbox up time."""
+    end_at: datetime
+    """Sandbox expiration date."""
+    timeout: int
+    """Sandbox timeout."""
+    envd_version: Optional[str]
+    """Envd version."""
+    _envd_access_token: Optional[str]
+    """Envd access token."""
+    object_storage: Optional[Dict[str, str]]
+    """Object storage."""
+
+
+@dataclass
+class ListedSandbox:
+    """Information about a sandbox."""
+
+    sandbox_id: str
+    """Sandbox ID."""
+    template_id: str
+    """Template ID."""
+    name: Optional[str]
+    """Template Alias."""
+    state: SandboxState
+    """Sandbox state."""
+    cpu_count: int
+    """Sandbox CPU count."""
+    memory_mb: int
+    """Sandbox Memory size in MB."""
+    metadata: Dict[str, str]
+    """Saved sandbox metadata."""
+    started_at: datetime
+    """Sandbox start time."""
+    uptime: int
+    """Sandbox up time."""
+    end_at: datetime
+    """Sandbox expiration date."""
+    timeout: int
+    """Sandbox timeout."""
+    object_storage: Optional[Dict[str, str]]
+    """Object storage."""
+
+
+@dataclass
+class SandboxQuery:
+    """Query parameters for listing sandboxes."""
+
+    metadata: Optional[dict[str, str]] = None
+    """Filter sandboxes by metadata."""
+
+
+@dataclass
+class SandboxMetrics:
+    """Sandbox metrics."""
+
+    cpu_count: int
+    """Number of CPUs."""
+    cpu_used_pct: float
+    """CPU usage percentage."""
+    disk_total: int
+    """Total disk space in bytes."""
+    disk_used: int
+    """Disk used in bytes."""
+    mem_total: int
+    """Total memory in bytes."""
+    mem_used: int
+    """Memory used in bytes."""
+    timestamp: datetime
+    """Timestamp of the metric entry."""
+
+
+class SandboxApiBase(ABC):
+    _limits = Limits(
+        max_keepalive_connections=10,
+        max_connections=20,
+        keepalive_expiry=20,
+    )
+    default_sandbox_timeout = 300