solari-e2b-compat 0.1.0__py3-none-any.whl

solari_e2b/_filesystem.py

@@ -0,0 +1,226 @@
+"""E2B ``sandbox.files``. Relative paths resolve against the guest's $HOME. Solari's listing carries name/dir/size; mode and
+mtime come from a stat per entry; owner and group are not exposed."""
+
+from __future__ import annotations
+
+import asyncio
+import io
+from datetime import datetime, timezone
+from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Union
+
+from ._box import Box, fire
+from .exceptions import FileNotFoundException, InvalidArgumentException, SolariCompatUnsupported
+from .models import EntryInfo, FilesystemEvent, FilesystemEventType, FileType, WriteEntry, WriteInfo
+
+
+def _permissions(mode: int, is_dir: bool) -> str:
+    bits = "rwxrwxrwx"
+    return ("d" if is_dir else "-") + "".join(bits[i] if mode & (1 << (8 - i)) else "-" for i in range(9))
+
+
+def _dirname(p: str) -> str:
+    i = p.rfind("/")
+    return "/" if i <= 0 else p[:i]
+
+
+def _to_bytes(data: Any) -> bytes:
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    if isinstance(data, (bytes, bytearray, memoryview)):
+        return bytes(data)
+    if isinstance(data, io.IOBase) or hasattr(data, "read"):
+        out = data.read()
+        return out.encode("utf-8") if isinstance(out, str) else bytes(out)
+    raise InvalidArgumentException("Unsupported data type for write: use str, bytes or a file-like object")
+
+
+def _reject(user: Optional[str], what: str, metadata: Optional[Dict[str, str]] = None) -> None:
+    if user:
+        raise SolariCompatUnsupported(f"{what} user", "Solari runs file operations as the sandbox's default user")
+    if metadata:
+        raise SolariCompatUnsupported(f"{what} metadata", "file extended attributes are not stored")
+
+
+class AsyncFileStreamReader:
+    """``read(format='stream')``: an async iterator over the file's bytes (a single chunk)."""
+
+    def __init__(self, data: bytes) -> None:
+        self._data: Optional[bytes] = data
+
+    def __aiter__(self) -> AsyncIterator[bytes]:
+        return self
+
+    async def __anext__(self) -> bytes:
+        if self._data is None:
+            raise StopAsyncIteration
+        d, self._data = self._data, None
+        return d
+
+    async def aclose(self) -> None:
+        self._data = None
+
+
+class AsyncWatchHandle:
+    def __init__(self, unwatch: Callable[[], Any]) -> None:
+        self._unwatch = unwatch
+        self._stopped = False
+
+    async def stop(self) -> None:
+        if self._stopped:
+            return
+        self._stopped = True
+        await self._unwatch()
+
+
+class AsyncFilesystem:
+    def __init__(self, box: Box) -> None:
+        self._box = box
+
+    async def read(self, path: str, format: str = "text", user: Optional[str] = None, request_timeout: Optional[float] = None, gzip: bool = False, stream_idle_timeout: Optional[float] = None):
+        _reject(user, "files.read")
+        if format not in ("text", "bytes", "stream"):
+            raise InvalidArgumentException(f"unknown format {format!r}: use 'text', 'bytes' or 'stream'")
+        abs_ = await self._box.abs(path)
+        data = await self._box.on(lambda sb: sb.files.read(abs_), "file")
+        if format == "bytes":
+            return bytearray(data)
+        if format == "stream":
+            return AsyncFileStreamReader(bytes(data))
+        return bytes(data).decode("utf-8", "replace")
+
+    async def write(self, path: str, data: Union[str, bytes, io.IOBase], user: Optional[str] = None, request_timeout: Optional[float] = None, gzip: bool = False, use_octet_stream: Optional[bool] = None, metadata: Optional[Dict[str, str]] = None) -> WriteInfo:
+        _reject(user, "files.write", metadata)
+        abs_ = await self._box.abs(path)
+        raw = _to_bytes(data)
+
+        async def _w(sb: Any) -> None:
+            # E2B creates missing parent directories.
+            try:
+                await sb.files.mkdir(_dirname(abs_))
+            except Exception:  # noqa: BLE001
+                pass
+            await sb.files.write(abs_, raw)
+
+        await self._box.on(_w, "file")
+        return WriteInfo(name=abs_[abs_.rfind("/") + 1:], type=FileType.FILE, path=abs_)
+
+    async def write_files(self, files: List[WriteEntry], user: Optional[str] = None, request_timeout: Optional[float] = None, gzip: bool = False, use_octet_stream: Optional[bool] = None, metadata: Optional[Dict[str, str]] = None) -> List[WriteInfo]:
+        return [await self.write(f["path"], f["data"], user, request_timeout, gzip, use_octet_stream, metadata) for f in files]
+
+    async def _info(self, abs_: str) -> EntryInfo:
+        st = await self._box.on(lambda sb: sb.files.stat(abs_), "file")
+        is_dir = bool(st.dir)
+        return EntryInfo(
+            name=st.name or abs_[abs_.rfind("/") + 1:],
+            type=FileType.DIR if is_dir else FileType.FILE,
+            path=abs_,
+            size=st.size,
+            mode=st.mode & 0o7777,
+            permissions=_permissions(st.mode, is_dir),
+            owner="",
+            group="",
+            modified_time=datetime.fromtimestamp(st.modTimeMs / 1000, tz=timezone.utc),
+        )
+
+    async def list(self, path: str, depth: Optional[int] = 1, user: Optional[str] = None, request_timeout: Optional[float] = None) -> List[EntryInfo]:
+        _reject(user, "files.list")
+        depth = 1 if depth is None else depth
+        if depth < 1:
+            raise InvalidArgumentException("depth should be at least one")
+        root = await self._box.abs(path)
+        if len(root) > 1:
+            root = root.rstrip("/") or "/"
+        out: List[EntryInfo] = []
+        sem = asyncio.Semaphore(8)
+
+        async def one(dir_: str, name: str) -> EntryInfo:
+            async with sem:
+                return await self._info(f"{'' if dir_ == '/' else dir_}/{name}")
+
+        async def walk(dir_: str, left: int) -> None:
+            entries = await self._box.on(lambda sb: sb.files.list(dir_), "file")
+            infos = await asyncio.gather(*(one(dir_, e.name) for e in entries))
+            out.extend(infos)
+            if left > 1:
+                for i in infos:
+                    if i.type == FileType.DIR:
+                        await walk(i.path, left - 1)
+
+        await walk(root, depth)
+        return out
+
+    async def get_info(self, path: str, user: Optional[str] = None, request_timeout: Optional[float] = None) -> EntryInfo:
+        _reject(user, "files.get_info")
+        return await self._info(await self._box.abs(path))
+
+    async def exists(self, path: str, user: Optional[str] = None, request_timeout: Optional[float] = None) -> bool:
+        _reject(user, "files.exists")
+        try:
+            await self._info(await self._box.abs(path))
+            return True
+        except FileNotFoundException:
+            return False
+        except Exception as e:  # noqa: BLE001
+            if "no such file" in str(e).lower() or "not exist" in str(e).lower() or "not found" in str(e).lower():
+                return False
+            raise
+
+    async def make_dir(self, path: str, user: Optional[str] = None, request_timeout: Optional[float] = None) -> bool:
+        _reject(user, "files.make_dir")
+        abs_ = await self._box.abs(path)
+        if await self.exists(abs_):
+            return False
+        await self._box.on(lambda sb: sb.files.mkdir(abs_), "file")
+        return True
+
+    async def rename(self, old_path: str, new_path: str, user: Optional[str] = None, request_timeout: Optional[float] = None) -> EntryInfo:
+        _reject(user, "files.rename")
+        a, b = await self._box.abs(old_path), await self._box.abs(new_path)
+        await self._box.on(lambda sb: sb.files.rename(a, b), "file")
+        return await self._info(b)
+
+    async def remove(self, path: str, user: Optional[str] = None, request_timeout: Optional[float] = None) -> None:
+        _reject(user, "files.remove")
+        abs_ = await self._box.abs(path)
+        await self._box.on(lambda sb: sb.files.remove(abs_, True), "file")
+
+    async def watch_dir(
+        self,
+        path: str,
+        on_event: Callable[[FilesystemEvent], Any],
+        on_exit: Optional[Callable[[Optional[Exception]], Any]] = None,
+        user: Optional[str] = None,
+        request_timeout: Optional[float] = None,
+        timeout: Optional[float] = 60,
+        recursive: bool = False,
+    ) -> AsyncWatchHandle:
+        _reject(user, "files.watch_dir")
+        abs_ = await self._box.abs(path)
+        base = abs_.rstrip("/")
+        valid = {t.value for t in FilesystemEventType}
+
+        def _cb(ev: Any) -> None:
+            typ = FilesystemEventType(ev.type) if ev.type in valid else FilesystemEventType.WRITE
+            name = ev.path[len(base) + 1:] if ev.path.startswith(base + "/") else ev.path
+            fire(on_event, FilesystemEvent(name=name, type=typ))
+
+        unwatch = await self._box.on(lambda sb: sb.files.watch(abs_, _cb, recursive))
+        timer: List[Optional["asyncio.TimerHandle"]] = [None]
+
+        async def _stop() -> None:
+            if timer[0] is not None:
+                timer[0].cancel()
+            try:
+                await unwatch()
+            except Exception:  # noqa: BLE001
+                pass
+
+        handle = AsyncWatchHandle(_stop)
+        # E2B ends a watch after ``timeout`` seconds (default 60; 0 disables).
+        if timeout and timeout > 0:
+            async def _expire() -> None:
+                await handle.stop()
+                fire(on_exit, None)
+
+            timer[0] = asyncio.get_running_loop().call_later(timeout, lambda: asyncio.ensure_future(_expire()))
+        return handle

solari_e2b/_loop.py

@@ -0,0 +1,49 @@
+"""Run coroutines from synchronous code on one background event loop (same design as solari_runloop._loop).
+
+Commands, streaming and file RPCs need a loop that keeps running between calls, so the sync API owns one daemon thread
+running a loop for the process lifetime. User callbacks passed to the sync API run on that thread."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Any, Coroutine, Optional, TypeVar
+
+T = TypeVar("T")
+
+
+class LoopThread:
+    def __init__(self) -> None:
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+    def _ensure(self) -> asyncio.AbstractEventLoop:
+        with self._lock:
+            if self._loop is None:
+                ready = threading.Event()
+                holder: dict = {}
+
+                def run() -> None:
+                    loop = asyncio.new_event_loop()
+                    holder["loop"] = loop
+                    asyncio.set_event_loop(loop)
+                    ready.set()
+                    loop.run_forever()
+
+                t = threading.Thread(target=run, name="solari-e2b-loop", daemon=True)
+                t.start()
+                ready.wait()
+                self._loop = holder["loop"]
+                self._thread = t
+            return self._loop
+
+    def run(self, coro: "Coroutine[Any, Any, T]") -> T:
+        loop = self._ensure()
+        if self._thread is not None and threading.current_thread() is self._thread:
+            coro.close()
+            raise RuntimeError("the sync solari_e2b API was called from inside its own event loop (from a streaming callback?); use AsyncSandbox there")
+        return asyncio.run_coroutine_threadsafe(coro, loop).result()
+
+
+LOOP = LoopThread()