agent-sandbox-backends 0.1.0__py3-none-any.whl

agent_sandbox_backends/__init__.py

@@ -0,0 +1,97 @@
+from agent_sandbox_backends.api import (
+    SandboxBackend,
+    create_allocator,
+    create_backend,
+    create_opensandbox_backend,
+)
+from agent_sandbox_backends.application.allocator import SandboxAllocator
+from agent_sandbox_backends.application.command_handle import CommandHandle
+from agent_sandbox_backends.config.command import CommandResultConfig
+from agent_sandbox_backends.config.concurrency import ConcurrencyConfig
+from agent_sandbox_backends.config.models import BackendMode, CleanupPolicy
+from agent_sandbox_backends.config.retry import RetryConfig
+from agent_sandbox_backends.config.upload import UploadConfig
+from agent_sandbox_backends.domain.capabilities import Capabilities, CapabilitySupport
+from agent_sandbox_backends.domain.commands import (
+    CommandOutputChunk,
+    CommandStream,
+    ExecRequest,
+    ExecResult,
+)
+from agent_sandbox_backends.domain.errors import (
+    BackendCloseError,
+    CommandExecutionError,
+    CommandQueueTimeoutError,
+    ConcurrentModificationError,
+    FileNotFoundError,
+    HistoryDatabaseError,
+    HistoryTransportError,
+    LockAcquisitionTimeoutError,
+    ProviderError,
+    SandboxBackendError,
+    SandboxDeletingError,
+    SandboxNotFoundError,
+    SandboxStateError,
+    UnsupportedCapabilityError,
+    UploadPartialFailureError,
+    UploadPolicyError,
+)
+from agent_sandbox_backends.domain.files import FileEntry, FileKind, WriteFileRequest
+from agent_sandbox_backends.domain.identity import SandboxRef
+from agent_sandbox_backends.domain.sandbox import (
+    SANDBOX_NAME_METADATA_KEY,
+    SandboxInfo,
+    SandboxState,
+)
+from agent_sandbox_backends.domain.uploads import UploadResult, UploadSpec
+from agent_sandbox_backends.history.config import HistoryConfig, HistoryMode
+from agent_sandbox_backends.version import __version__
+
+__all__ = [
+    "SANDBOX_NAME_METADATA_KEY",
+    "BackendCloseError",
+    "BackendMode",
+    "Capabilities",
+    "CapabilitySupport",
+    "CleanupPolicy",
+    "CommandExecutionError",
+    "CommandHandle",
+    "CommandOutputChunk",
+    "CommandQueueTimeoutError",
+    "CommandResultConfig",
+    "CommandStream",
+    "ConcurrencyConfig",
+    "ConcurrentModificationError",
+    "ExecRequest",
+    "ExecResult",
+    "FileEntry",
+    "FileKind",
+    "FileNotFoundError",
+    "HistoryConfig",
+    "HistoryDatabaseError",
+    "HistoryMode",
+    "HistoryTransportError",
+    "LockAcquisitionTimeoutError",
+    "ProviderError",
+    "RetryConfig",
+    "SandboxAllocator",
+    "SandboxBackend",
+    "SandboxBackendError",
+    "SandboxDeletingError",
+    "SandboxInfo",
+    "SandboxNotFoundError",
+    "SandboxRef",
+    "SandboxState",
+    "SandboxStateError",
+    "UnsupportedCapabilityError",
+    "UploadConfig",
+    "UploadPartialFailureError",
+    "UploadPolicyError",
+    "UploadResult",
+    "UploadSpec",
+    "WriteFileRequest",
+    "__version__",
+    "create_allocator",
+    "create_backend",
+    "create_opensandbox_backend",
+]

agent_sandbox_backends/_internal/__init__.py

@@ -0,0 +1 @@
+"""Internal implementation helpers."""

agent_sandbox_backends/_internal/bounded_output.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections import deque
+
+
+class BoundedHeadTailBuffer:
+    def __init__(self, *, max_bytes: int, tail_bytes: int) -> None:
+        self._max_bytes = max_bytes
+        self._tail_capacity = min(max_bytes, tail_bytes)
+        self._head_capacity = max_bytes - self._tail_capacity
+        self._head = bytearray()
+        self._tail: deque[bytes] = deque()
+        self._tail_size = 0
+        self.total_bytes = 0
+
+    @property
+    def truncated(self) -> bool:
+        return self.total_bytes > self._max_bytes
+
+    def append(self, data: bytes) -> None:
+        if not data:
+            return
+        self.total_bytes += len(data)
+        head_missing = self._head_capacity - len(self._head)
+        if head_missing > 0:
+            self._head.extend(data[:head_missing])
+            data = data[head_missing:]
+        if self._tail_capacity == 0 or not data:
+            return
+        self._tail.append(data)
+        self._tail_size += len(data)
+        self._trim_tail()
+
+    def value(self) -> bytes:
+        if not self._tail:
+            return bytes(self._head)
+        return bytes(self._head) + b"".join(self._tail)
+
+    def _trim_tail(self) -> None:
+        overflow = self._tail_size - self._tail_capacity
+        while overflow > 0 and self._tail:
+            first = self._tail[0]
+            if len(first) <= overflow:
+                self._tail.popleft()
+                self._tail_size -= len(first)
+                overflow -= len(first)
+                continue
+            self._tail[0] = first[overflow:]
+            self._tail_size -= overflow
+            overflow = 0

agent_sandbox_backends/_internal/ids.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import secrets
+import threading
+import time
+import uuid
+
+_lock = threading.Lock()
+_last_millisecond = -1
+_sequence = 0
+_SEQUENCE_MASK = (1 << 74) - 1
+
+
+def uuid7() -> uuid.UUID:
+    """Return a process-monotonic UUIDv7 compatible identifier."""
+    global _last_millisecond, _sequence
+
+    millisecond = time.time_ns() // 1_000_000
+    with _lock:
+        if millisecond > _last_millisecond:
+            _last_millisecond = millisecond
+            _sequence = secrets.randbits(74)
+        else:
+            millisecond = _last_millisecond
+            _sequence = (_sequence + 1) & _SEQUENCE_MASK
+            if _sequence == 0:
+                _last_millisecond += 1
+                millisecond = _last_millisecond
+
+        random_a = (_sequence >> 62) & 0xFFF
+        random_b = _sequence & ((1 << 62) - 1)
+
+    value = (millisecond & ((1 << 48) - 1)) << 80
+    value |= 0x7 << 76
+    value |= random_a << 64
+    value |= 0b10 << 62
+    value |= random_b
+    return uuid.UUID(int=value)