solari-e2b-compat 0.1.0__tar.gz → 0.2.0__tar.gz

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/COMPAT.md

@@ -41,7 +41,7 @@ and the differences that are specific to Python.
 | `get_metrics()` | DIFF | One current sample (no history); `mem_cache` is 0. |
 | `pause()` | OK, live | Keeps RAM and disk. `mode='filesystem'`, `keep_memory=False`: treated as a full pause. |
 | `create_snapshot(name=)`, `list_snapshots(...)`, `Sandbox.delete_snapshot(id)` | OK, live | Snapshots are RAM + disk. `mode='filesystem'` is ignored. A name lookup reads at most 1000 snapshots. `sbx.list_snapshots()` lists snapshots taken of that sandbox. Class-level listing over every sandbox is `Sandbox.list_all_snapshots(name=)` (extension). |
-| `fork(count=)` | DIFF, live | Checkpoint then `count` new sandboxes from it; the checkpoint is deleted afterwards (waiting at most 20 s for the gateway to finish the delete). Returns a sandbox or an exception per copy. |
+| `fork(count=)` | DIFF, live | Checkpoint then `count` new sandboxes from it; the gateway will not delete a checkpoint while a copy is alive, so each copy carries the checkpoint id in a hidden metadata key (`e2b.forkSnapshot`, not shown in `info.metadata`; you cannot set it yourself) and the **last copy killed deletes it** (waiting up to ~40 s). A copy that is not killed (it expires on its idle timeout) keeps the checkpoint, which is billed snapshot storage: kill your copies. Returns a sandbox or an exception per copy. |
 | `get_host(port)` | NO | E2B returns the host synchronously; Solari mints preview URLs on the gateway. Use the extension `sbx.get_preview_url(port)` (returns `{'url': ..., 'token': ...}`). |
 | `upload_url`, `download_url` | OK | `user=`: NO. |
 | `update_network`, `get_mcp_url`, `get_mcp_token` (returns `None`), `git` | NO | `git` is deprecated in E2B; use `commands.run('git …')`. |

solari_e2b_compat-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Solari Desktop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.5
 Name: solari-e2b-compat
-Version: 0.1.0
+Version: 0.2.0
 Summary: E2B-compatible Python interface (sandboxes and code interpreter) over Solari Sandboxes. Not affiliated with E2B.
 Project-URL: Homepage, https://getsolari.com
 Author: Solari
 License: MIT
+License-File: LICENSE
 License-File: LICENSE-E2B
 License-File: NOTICE
 Keywords: code-interpreter,compatibility,e2b,sandbox,solari

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "solari-e2b-compat"
-version = "0.1.0"
+version = "0.2.0"
 description = "E2B-compatible Python interface (sandboxes and code interpreter) over Solari Sandboxes. Not affiliated with E2B."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -23,7 +23,7 @@ Homepage = "https://getsolari.com"
 packages = ["solari_e2b"]
 
 [tool.hatch.build.targets.sdist]
-include = ["solari_e2b", "README.md", "COMPAT.md", "NOTICE", "LICENSE-E2B"]
+include = ["solari_e2b", "README.md", "COMPAT.md", "NOTICE", "LICENSE", "LICENSE-E2B"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/solari_e2b/__init__.py

@@ -36,4 +36,4 @@ from .models import *  # noqa: F401,F403
 Volume = _Unsupported("Volume")
 Secret = _Unsupported("Secret")
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/solari_e2b/_config.py

@@ -99,7 +99,10 @@ def _resolve(opts: Dict[str, Any]) -> Tuple[str, str]:
                 _describe(inherited_raw),
                 DEFAULT_BASE_URL,
             )
-    return key, (base or os.environ.get("SOLARI_BASE_URL") or inherited or DEFAULT_BASE_URL).rstrip("/")
+    env_base = os.environ.get("SOLARI_BASE_URL")
+    if not base and env_base and not is_solari_base_url(env_base):
+        raise SandboxException(f"Refusing to send a Solari API key to {_describe(env_base)}: it does not point at Solari.")
+    return key, (base or env_base or inherited or DEFAULT_BASE_URL).rstrip("/")
 
 
 def resolve_conn(**opts: Any) -> Conn:

{solari_e2b_compat-0.1.0 → solari_e2b_compat-0.2.0}/solari_e2b/_sandbox.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import functools
 import inspect
+import logging
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import quote, urlencode
@@ -35,13 +36,46 @@ def _parse_time(s: Optional[str]) -> datetime:
     return datetime.fromisoformat(s.replace("Z", "+00:00"))
 
 
+log = logging.getLogger("solari_e2b")
+
+#: Reserved metadata key (hidden from ``info.metadata``): the checkpoint a fork was booted from, deleted with the last copy.
+FORK_KEY = "e2b.forkSnapshot"
+
+
+def _public_metadata(m: Optional[Dict[str, str]]) -> Dict[str, str]:
+    return {k: v for k, v in (m or {}).items() if k != FORK_KEY}
+
+
+async def _release_fork_snapshot(conn: Any, snapshot_id: str, self_id: str) -> None:
+    """Delete a fork's checkpoint once no copy that needs it is left. The gateway refuses while a copy is alive, so this runs
+    after the last copy is killed (it waits for that sandbox's release to settle, about 40 s at most) and says so if it fails."""
+    try:
+        listed = await conn.solari.list(metadata={FORK_KEY: snapshot_id}, limit=50)
+        views = [_view_dict(x) for x in listed["sandboxes"]]
+        if any(v.get("sandboxId") != self_id and v.get("state") not in ("gone", "releasing") for v in views):
+            return  # another live copy still needs it; the last one to be killed deletes it (one that is only "releasing" no longer does)
+        last: Optional[BaseException] = None
+        for _ in range(20):
+            try:
+                await conn.solari.delete_snapshot(snapshot_id)
+                return
+            except Exception as e:  # noqa: BLE001
+                if getattr(e, "status", None) == 404:  # another copy killed at the same time already deleted it
+                    return
+                last = e
+                await asyncio.sleep(2)
+        log.warning("could not delete the fork checkpoint %s (%s); delete it with Sandbox.delete_snapshot(%r)", snapshot_id, last, snapshot_id)
+    except Exception:  # noqa: BLE001
+        pass
+
+
 def to_info(v: Dict[str, Any]) -> SandboxInfo:
     state = "paused" if v.get("state") in ("paused", "stopped") else "running"
     return SandboxInfo(
         sandbox_id=v["sandboxId"],
         template_id="",
         name=v.get("name"),
-        metadata=v.get("metadata") or {},
+        metadata=_public_metadata(v.get("metadata")),
         started_at=_parse_time(v.get("createdAt") or v.get("startedAt")),
         end_at=_parse_time(v.get("expiresAt")),
         state=state,
@@ -224,6 +258,9 @@ class AsyncSandbox:
             raise SolariCompatUnsupported("iam")
         if allow_internet_access is False:
             raise SolariCompatUnsupported("allow_internet_access=False", "Solari sandboxes always have internet access")
+        # A caller could otherwise name another sandbox's checkpoint here, and killing this sandbox would then delete it.
+        if metadata and FORK_KEY in metadata:
+            raise SolariCompatUnsupported(f"metadata key {FORK_KEY!r}", "this key is reserved by the compatibility layer")
         conn = resolve_conn(**split_opts(opts)[0])
         volumes = await _resolve_volumes(conn, volume_mounts) if volume_mounts else None
         try:
@@ -280,8 +317,11 @@ class AsyncSandbox:
         # The gateway's DELETE is idempotent; E2B reports False for a sandbox that is already gone.
         await self._box.close()
         try:
-            await get_view(self._box.conn, self._sandbox_id)
+            view = await get_view(self._box.conn, self._sandbox_id)
             await self._box.conn.solari.kill(self._sandbox_id)
+            fork = (view.get("metadata") or {}).get(FORK_KEY)
+            if fork:
+                await _release_fork_snapshot(self._box.conn, fork, self._sandbox_id)
             return True
         except Exception as e:  # noqa: BLE001
             t = translate(e, "sandbox")
@@ -379,23 +419,26 @@ class AsyncSandbox:
         try:
             view = await get_view(conn, self._sandbox_id)
             snap = (await self.create_snapshot()).snapshot_id
+            parent_md = _public_metadata(view.get("metadata"))
         except Exception as e:  # noqa: BLE001
             raise translate(e, "sandbox") from e
 
         async def one() -> Any:
             try:
-                core = await conn.solari.create(from_snapshot=snap, timeout_ms=int((timeout if timeout is not None else DEFAULT_TIMEOUT) * 1000), metadata=view.get("metadata") or None)
+                core = await conn.solari.create(from_snapshot=snap, timeout_ms=int((timeout if timeout is not None else DEFAULT_TIMEOUT) * 1000), metadata={**parent_md, FORK_KEY: snap})
                 return cls(conn, core.sandboxId, core)
             except Exception as e:  # noqa: BLE001
                 t = translate(e)
                 return t if isinstance(t, BaseException) else SandboxException(str(t))
 
         forks = await asyncio.gather(*(one() for _ in range(n)))
-        # The checkpoint was made for this call only: release it once the copies are up (best effort, bounded).
-        try:
-            await asyncio.wait_for(conn.solari.delete_snapshot(snap), 20)
-        except Exception:  # noqa: BLE001
-            pass
+        # The checkpoint was made for this call only. While a copy is alive the gateway refuses to delete it; the copies carry its
+        # id (FORK_KEY) and the last one killed deletes it (see ``kill``). If no copy came up there is nothing to wait for.
+        if all(isinstance(f, BaseException) for f in forks):
+            try:
+                await asyncio.wait_for(conn.solari.delete_snapshot(snap), 20)
+            except Exception:  # noqa: BLE001
+                pass
         return list(forks)
 
     # --- network / urls ---