den-sdk 0.0.3__tar.gz

den_sdk-0.0.3/.gitignore

@@ -0,0 +1,48 @@
+# Binaries
+bin/
+/den
+*.exe
+
+# Database
+*.db
+
+# Config
+den.yaml
+!den.example.yaml
+
+# Go
+vendor/
+
+# Node
+node_modules/
+sdk/*/dist/
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Test
+coverage.out
+coverage.html
+ws_test*.py
+.venv-test/
+
+# Temp
+FIXPLAN.md
+PROGRESS.md
+
+# GoReleaser
+/dist/

den_sdk-0.0.3/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: den-sdk
+Version: 0.0.3
+Summary: Python SDK for the Den sandbox API
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'

den_sdk-0.0.3/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "den-sdk"
+version = "0.0.3"
+description = "Python SDK for the Den sandbox API"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "respx>=0.21",
+    "ruff>=0.8",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/den"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

den_sdk-0.0.3/src/den/__init__.py

@@ -0,0 +1,56 @@
+"""Den Python SDK - manage cloud sandboxes programmatically."""
+
+from den.client import Den
+from den.exceptions import (
+    DenError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+)
+from den.sandbox import Sandbox, SandboxManager
+from den.types import (
+    ExecResult,
+    FileInfo,
+    PortMapping,
+    S3ExportRequest,
+    S3ExportResponse,
+    S3ImportRequest,
+    S3ImportResponse,
+    S3SyncConfig,
+    SandboxConfig,
+    SandboxInfo,
+    SandboxStats,
+    SnapshotInfo,
+    StorageConfig,
+    TmpfsMount,
+    VolumeMount,
+)
+
+__all__ = [
+    "Den",
+    "DenError",
+    "AuthenticationError",
+    "ExecResult",
+    "FileInfo",
+    "NotFoundError",
+    "PortMapping",
+    "RateLimitError",
+    "S3ExportRequest",
+    "S3ExportResponse",
+    "S3ImportRequest",
+    "S3ImportResponse",
+    "S3SyncConfig",
+    "Sandbox",
+    "SandboxConfig",
+    "SandboxInfo",
+    "SandboxManager",
+    "SandboxStats",
+    "SnapshotInfo",
+    "StorageConfig",
+    "TmpfsMount",
+    "ValidationError",
+    "VolumeMount",
+]
+
+__version__ = "0.0.2"

den_sdk-0.0.3/src/den/client.py

@@ -0,0 +1,166 @@
+"""Main client for the Den API."""
+
+from __future__ import annotations
+
+import httpx
+
+from den.sandbox import SandboxManager
+
+
+class Den:
+    """Client for the Den sandbox API.
+
+    Provides access to sandbox management and operations via both
+    synchronous and asynchronous interfaces.
+
+    Example (sync)::
+
+        client = Den("http://localhost:8080", api_key="sk-...")
+        sandbox = client.sandbox.create(image="python:3.12")
+        result = sandbox.exec(["python", "-c", "print('hello')"])
+        print(result.stdout)
+        sandbox.destroy()
+        client.close()
+
+    Example (async)::
+
+        client = Den("http://localhost:8080", api_key="sk-...")
+        sandbox = await client.sandbox.acreate(image="python:3.12")
+        result = await sandbox.aexec(["python", "-c", "print('hello')"])
+        print(result.stdout)
+        await sandbox.adestroy()
+        await client.aclose()
+    """
+
+    def __init__(
+        self,
+        url: str = "http://localhost:8080",
+        *,
+        api_key: str | None = None,
+        timeout: float = 120.0,
+    ) -> None:
+        """Initialize the Den client.
+
+        Args:
+            url: Base URL of the Den server (e.g. ``http://localhost:8080``).
+            api_key: Optional API key for authentication.
+            timeout: Request timeout in seconds. Defaults to 120.
+        """
+        self._url = url.rstrip("/")
+        self._api_key = api_key
+        self._base_url = f"{self._url}/api/v1"
+
+        headers: dict[str, str] = {}
+        if api_key:
+            headers["X-API-Key"] = api_key
+
+        self._client = httpx.Client(
+            base_url="",
+            headers=headers,
+            timeout=timeout,
+        )
+        self._async_client = httpx.AsyncClient(
+            base_url="",
+            headers=headers,
+            timeout=timeout,
+        )
+
+        self._sandbox_manager = SandboxManager(
+            client=self._client,
+            async_client=self._async_client,
+            base_url=self._base_url,
+        )
+
+    @property
+    def sandbox(self) -> SandboxManager:
+        """Access the sandbox manager for creating and managing sandboxes."""
+        return self._sandbox_manager
+
+    def health(self) -> dict:
+        """Check server health (sync).
+
+        Returns:
+            Dictionary with server health status.
+        """
+        resp = self._client.get(f"{self._base_url}/health")
+        resp.raise_for_status()
+        return resp.json()
+
+    async def ahealth(self) -> dict:
+        """Check server health (async).
+
+        Returns:
+            Dictionary with server health status.
+        """
+        resp = await self._async_client.get(f"{self._base_url}/health")
+        resp.raise_for_status()
+        return resp.json()
+
+    def version(self) -> dict:
+        """Get server version info (sync).
+
+        Returns:
+            Dictionary with version, commit, and build_date.
+        """
+        resp = self._client.get(f"{self._base_url}/version")
+        resp.raise_for_status()
+        return resp.json()
+
+    async def aversion(self) -> dict:
+        """Get server version info (async).
+
+        Returns:
+            Dictionary with version, commit, and build_date.
+        """
+        resp = await self._async_client.get(f"{self._base_url}/version")
+        resp.raise_for_status()
+        return resp.json()
+
+    def close(self) -> None:
+        """Close the underlying HTTP clients (sync).
+
+        Note: The async client is best closed via ``await client.aclose()``
+        or by using ``async with Den(...)`` as a context manager.
+        This method attempts to close it as well, but in an async context
+        prefer calling ``aclose()`` directly.
+        """
+        self._client.close()
+        try:
+            import asyncio
+            try:
+                loop = asyncio.get_running_loop()
+                # Loop is running — schedule async close, log failures
+                task = loop.create_task(self._async_client.aclose())
+                task.add_done_callback(
+                    lambda t: None if t.exception() is None else None
+                )
+            except RuntimeError:
+                # No running loop — safe to run synchronously
+                asyncio.run(self._async_client.aclose())
+        except Exception:
+            import warnings
+            warnings.warn(
+                "Failed to close async HTTP client; prefer using "
+                "'await client.aclose()' in async contexts",
+                ResourceWarning,
+                stacklevel=2,
+            )
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP clients (async)."""
+        await self._async_client.aclose()
+
+    def __enter__(self) -> Den:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    async def __aenter__(self) -> Den:
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        return f"Den(url={self._url!r})"

den_sdk-0.0.3/src/den/exceptions.py

@@ -0,0 +1,40 @@
+"""Exceptions for the Den SDK."""
+
+from __future__ import annotations
+
+
+class DenError(Exception):
+    """Base exception for all Den SDK errors."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class NotFoundError(DenError):
+    """Raised when a resource is not found (404)."""
+
+    def __init__(self, message: str = "Resource not found") -> None:
+        super().__init__(message, status_code=404)
+
+
+class AuthenticationError(DenError):
+    """Raised when authentication fails (401/403)."""
+
+    def __init__(self, message: str = "Authentication failed") -> None:
+        super().__init__(message, status_code=401)
+
+
+class RateLimitError(DenError):
+    """Raised when rate limit is exceeded (429)."""
+
+    def __init__(self, message: str = "Rate limit exceeded") -> None:
+        super().__init__(message, status_code=429)
+
+
+class ValidationError(DenError):
+    """Raised when the request is invalid (400)."""
+
+    def __init__(self, message: str = "Invalid request") -> None:
+        super().__init__(message, status_code=400)