Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

WebSocket in separate thread (#91)

Jakub Novák04562c013396
diff --git a/packages/python-sdk/e2b/session/__init__.py b/packages/python-sdk/e2b/session/__init__.py
index 1d7e37f22..28b252b6b 100644
--- a/packages/python-sdk/e2b/session/__init__.py
+++ b/packages/python-sdk/e2b/session/__init__.py
@@ -1,14 +1,14 @@
-from .main import Session
-from .filesystem_watcher import FilesystemOperation, FilesystemWatcher, FilesystemEvent
-from .filesystem import FileInfo, FilesystemManager
-from .terminal import TerminalManager, Terminal, TerminalOutput
-from .process import ProcessManager, Process, ProcessMessage, ProcessOutput
from .code_snippet import OpenPort
from .env_vars import EnvVars
-from .session_rpc import RpcException
from .exception import (
- TerminalException,
- ProcessException,
FilesystemException,
+ ProcessException,
+ RpcException,
SessionException,
+ TerminalException,
)
+from .filesystem import FileInfo, FilesystemManager
+from .filesystem_watcher import FilesystemEvent, FilesystemOperation, FilesystemWatcher
+from .main import Session
+from .process import Process, ProcessManager, ProcessMessage, ProcessOutput
+from .terminal import Terminal, TerminalManager, TerminalOutput
diff --git a/packages/python-sdk/e2b/session/code_snippet.py b/packages/python-sdk/e2b/session/code_snippet.py
index 0bcfa0a23..53ace931d 100644
--- a/packages/python-sdk/e2b/session/code_snippet.py
+++ b/packages/python-sdk/e2b/session/code_snippet.py
@@ -1,9 +1,8 @@
-from typing import Optional, ClassVar, Callable, List, Any
-from pydantic import BaseModel
+from typing import Any, Callable, ClassVar, List, Optional
-from e2b.session.exception import SessionException, MultipleExceptions
+from e2b.session.exception import MultipleExceptions, RpcException, SessionException
from e2b.session.session_connection import SessionConnection
-from e2b.session.session_rpc import RpcException
+from pydantic import BaseModel
class OpenPort(BaseModel):
@@ -11,6 +10,7 @@ class OpenPort(BaseModel):
port: int
state: str
+
ScanOpenedPortsHandler = Callable[[List[OpenPort]], Any]
diff --git a/packages/python-sdk/e2b/session/exception.py b/packages/python-sdk/e2b/session/exception.py
index 769fe47c2..d8643702a 100644
--- a/packages/python-sdk/e2b/session/exception.py
+++ b/packages/python-sdk/e2b/session/exception.py
@@ -1,10 +1,25 @@
-from typing import List
+from typing import Dict, List, Optional
class SessionException(Exception):
pass
+class RpcException(SessionException):
+ def __init__(
+ self,
+ message: str,
+ code: int,
+ id: str,
+ data: Optional[Dict] = None,
+ ):
+ super().__init__(message)
+ self.data = data
+ self.code = code
+ self.message = message
+ self.id = id
+
+
class MultipleExceptions(Exception):
def __init__(self, message: str, exceptions: List[Exception]):
super().__init__(f"Multiple exceptions occurred: {message}")
diff --git a/packages/python-sdk/e2b/session/filesystem.py b/packages/python-sdk/e2b/session/filesystem.py
index 4ca678103..2bec99e1e 100644
--- a/packages/python-sdk/e2b/session/filesystem.py
+++ b/packages/python-sdk/e2b/session/filesystem.py
@@ -1,12 +1,10 @@
import base64
+from typing import Any, List
-from typing import List, Any
-from pydantic import BaseModel
-
-from e2b.session.session_connection import SessionConnection
+from e2b.session.exception import FilesystemException, RpcException
from e2b.session.filesystem_watcher import FilesystemWatcher
-from e2b.session.session_rpc import RpcException
-from e2b.session.exception import FilesystemException
+from e2b.session.session_connection import SessionConnection
+from pydantic import BaseModel
class FileInfo(BaseModel):
diff --git a/packages/python-sdk/e2b/session/filesystem_watcher.py b/packages/python-sdk/e2b/session/filesystem_watcher.py
index 2437b06ff..bf2d34734 100644
--- a/packages/python-sdk/e2b/session/filesystem_watcher.py
+++ b/packages/python-sdk/e2b/session/filesystem_watcher.py
@@ -1,10 +1,9 @@
from enum import Enum
-from typing import Callable, Set, Any, Awaitable, Optional
-from pydantic import BaseModel
+from typing import Any, Awaitable, Callable, Optional, Set
+from e2b.session.exception import FilesystemException, RpcException
from e2b.session.session_connection import SessionConnection
-from e2b.session.exception import FilesystemException
-from e2b.session.session_rpc import RpcException
+from pydantic import BaseModel
class FilesystemOperation(str, Enum):
diff --git a/packages/python-sdk/e2b/session/process.py b/packages/python-sdk/e2b/session/process.py
index 36857f334..1c4700c3c 100644
--- a/packages/python-sdk/e2b/session/process.py
+++ b/packages/python-sdk/e2b/session/process.py
@@ -1,18 +1,14 @@
import asyncio
import logging
+from typing import Any, Awaitable, Callable, ClassVar, Coroutine, Dict, List, Optional
-from typing import Awaitable, ClassVar, Optional, Callable, Any, Coroutine, List, Dict
-from pydantic import BaseModel
-
-from e2b.utils.noop import noop
-from e2b.session.out import OutStdoutResponse, OutStderrResponse
-from e2b.utils.future import DeferredFuture
from e2b.session.env_vars import EnvVars
+from e2b.session.exception import MultipleExceptions, ProcessException, RpcException
+from e2b.session.out import OutStderrResponse, OutStdoutResponse
from e2b.session.session_connection import SessionConnection
+from e2b.utils.future import DeferredFuture
from e2b.utils.id import create_id
-from e2b.session.session_rpc import RpcException
-from e2b.session.exception import ProcessException, MultipleExceptions
-
+from pydantic import BaseModel
logger = logging.getLogger(__name__)
diff --git a/packages/python-sdk/e2b/session/session_connection.py b/packages/python-sdk/e2b/session/session_connection.py
index 285d9e8ac..95593489f 100644
--- a/packages/python-sdk/e2b/session/session_connection.py
+++ b/packages/python-sdk/e2b/session/session_connection.py
@@ -1,29 +1,23 @@
import asyncio
-from concurrent.futures import ThreadPoolExecutor
import logging
import traceback
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Awaitable, Callable, List, Literal, Optional
-from typing import Awaitable, Literal, Optional, Callable, List, Any
-from pydantic import BaseModel
-
+from e2b.api.client import NewSession
+from e2b.api.client import Session as SessionInfo
from e2b.api.client.rest import ApiException
+from e2b.api.main import client, configuration
+from e2b.constants import SESSION_DOMAIN, SESSION_REFRESH_PERIOD, WS_PORT, WS_ROUTE
from e2b.session.exception import (
+ AuthenticationException,
MultipleExceptions,
SessionException,
- AuthenticationException,
)
-from e2b.utils.future import DeferredFuture
-from e2b.session.session_rpc import SessionRpc, Notification
-from e2b.api.client import NewSession, Session as SessionInfo
+from e2b.session.session_rpc import Notification, SessionRpc
+from e2b.utils.future import DeferredFuture, run_async_func_in_new_loop
from e2b.utils.noop import noop
-from e2b.utils.future import run_async_func_in_new_loop
-from e2b.api.main import client, configuration
-from e2b.constants import (
- SESSION_DOMAIN,
- WS_PORT,
- WS_ROUTE,
- SESSION_REFRESH_PERIOD,
-)
+from pydantic import BaseModel
logger = logging.getLogger(__name__)
diff --git a/packages/python-sdk/e2b/session/session_rpc.py b/packages/python-sdk/e2b/session/session_rpc.py
index 4fb356bf6..6f6edb6df 100644
--- a/packages/python-sdk/e2b/session/session_rpc.py
+++ b/packages/python-sdk/e2b/session/session_rpc.py
@@ -1,47 +1,24 @@
import asyncio
import json
import logging
-
+from concurrent.futures import ThreadPoolExecutor
+from queue import Queue
from threading import Event
-from websockets.client import WebSocketClientProtocol, connect
-from typing import (
- Callable,
- Optional,
- Any,
- Dict,
- List,
- Union,
- Iterable,
- Iterator,
-)
-from pydantic import BaseModel, PrivateAttr
-from jsonrpcclient import request_json, Ok
+from typing import Any, Callable, Dict, Iterator, List
+
+from e2b.session.exception import RpcException
+from e2b.session.websocket_client import WebSocket
+from e2b.utils.future import DeferredFuture, run_async_func_in_new_loop
+from janus import Queue as JanusQueue
+from jsonrpcclient import Error, Ok, request_json
from jsonrpcclient.id_generators import decimal as decimal_id_generator
-from jsonrpcclient.responses import Response, Error, Deserialized
+from jsonrpcclient.responses import Response
+from pydantic import BaseModel, PrivateAttr
from websockets.typing import Data
-from e2b.session.exception import SessionException
-from e2b.utils.future import run_async_func_in_new_loop
-from e2b.utils.future import DeferredFuture
-
logger = logging.getLogger(__name__)
-class RpcException(SessionException):
- def __init__(
- self,
- message: str,
- code: int,
- id: str,
- data: Optional[Dict] = None,
- ):
- super().__init__(message)
- self.data = data
- self.code = code
- self.message = message
- self.id = id
-
-
class Notification(BaseModel):
"""Nofification"""
@@ -71,90 +48,60 @@ def to_response_or_notification(response: Dict[str, Any]) -> Message:
raise ValueError("Invalid response", response)
-def parse(deserialized: Deserialized) -> Union[Message, Iterable[Message]]:
- """Create a Response or list of Responses from a dict or list of dicts"""
- if isinstance(deserialized, str):
- raise TypeError("Use parse_json on strings")
- return (
- map(to_response_or_notification, deserialized)
- if isinstance(deserialized, list)
- else to_response_or_notification(deserialized)
- )
-
-
class SessionRpc(BaseModel):
url: str
on_message: Callable[[Notification], None]
_id_generator: Iterator[int] = PrivateAttr(default_factory=decimal_id_generator)
_waiting_for_replies: Dict[int, DeferredFuture] = PrivateAttr(default_factory=dict)
- _ws: Optional[WebSocketClientProtocol] = PrivateAttr()
-
+ _queue_in: Queue[dict] = PrivateAttr(default_factory=Queue)
+ _queue_out: JanusQueue[Data] = PrivateAttr(default_factory=JanusQueue)
_process_cleanup: List[Callable[[], Any]] = PrivateAttr(default_factory=list)
class Config:
arbitrary_types_allowed = True
- async def connect(self):
- future_connect = DeferredFuture(self._process_cleanup)
-
- async def handle_messages():
- async with connect(
- self.url,
- ping_interval=None,
- ping_timeout=None,
- max_queue=None,
- max_size=None,
- ) as websocket:
- self._ws = websocket
- cancel_event = Event()
-
- self._process_cleanup.append(cancel_event.set)
-
- async def keep_pong():
- while not cancel_event.is_set():
- await asyncio.sleep(5)
- await websocket.pong()
-
- ponging = asyncio.to_thread(
- run_async_func_in_new_loop,
- keep_pong(),
- )
-
- ponging_task = asyncio.create_task(ponging)
- self._process_cleanup.append(ponging_task.cancel)
-
- logger.info(f"Connected to {self.url}")
- future_connect(None)
- try:
- async for message in self._ws:
- await self._receive_message(message)
- except Exception as e:
- logger.error(f"Error: {e}")
-
- if not self._ws:
- raise Exception("Not connected")
- async for message in self._ws:
- await self._receive_message(message)
+ async def process_messages(self):
+ while True:
+ data = await self._queue_out.async_q.get()
+ await self._receive_message(data)
+ self._queue_out.async_q.task_done()
- handle_messages_task = asyncio.create_task(handle_messages())
- self._process_cleanup.append(handle_messages_task.cancel)
- await future_connect
+ async def connect(self):
+ started = Event()
+ stopped = Event()
+ task = asyncio.create_task(self.process_messages())
+ executor = ThreadPoolExecutor()
+ websocket_task = executor.submit(
+ run_async_func_in_new_loop,
+ WebSocket(
+ url=self.url,
+ queue_in=self._queue_in,
+ queue_out=self._queue_out.sync_q,
+ started=started,
+ stopped=stopped,
+ ).run(),
+ )
+ self._process_cleanup.append(stopped.set)
+ self._process_cleanup.append(websocket_task.cancel)
+ self._process_cleanup.append(
+ lambda: executor.shutdown(wait=False, cancel_futures=True)
+ )
+ self._process_cleanup.append(task.cancel)
+ while not started.is_set():
+ await asyncio.sleep(0)
async def send_message(self, method: str, params: List[Any]) -> Any:
- if not self._ws:
- raise Exception("Not connected")
-
id = next(self._id_generator)
request = request_json(method, params, id)
future_reply = DeferredFuture(self._process_cleanup)
try:
self._waiting_for_replies[id] = future_reply
- logger.info(f"Sending request: {request}")
- await self._ws.send(request)
+ logger.info(f"Queueing: {request}")
+ self._queue_in.put(request)
+ logger.info(f"Waiting for reply: {request}")
r = await future_reply
- logger.info(f"Received reply: {r}")
return r
except Exception as e:
logger.error(f"Error: {request} {e}")
@@ -204,6 +151,3 @@ class SessionRpc(BaseModel):
async def close(self):
self._close()
-
- if self._ws:
- await self._ws.close()
diff --git a/packages/python-sdk/e2b/session/terminal.py b/packages/python-sdk/e2b/session/terminal.py
index 61732cab0..39bc96b17 100644
--- a/packages/python-sdk/e2b/session/terminal.py
+++ b/packages/python-sdk/e2b/session/terminal.py
@@ -1,15 +1,12 @@
import asyncio
+from typing import Any, Awaitable, Callable, Coroutine, List, Optional
-from typing import Awaitable, Callable, Optional, Coroutine, Any, List
-from pydantic import BaseModel
-
-from e2b.utils.noop import noop
-from e2b.utils.future import DeferredFuture
from e2b.session.env_vars import EnvVars
+from e2b.session.exception import MultipleExceptions, RpcException, TerminalException
from e2b.session.session_connection import SessionConnection
+from e2b.utils.future import DeferredFuture
from e2b.utils.id import create_id
-from e2b.session.exception import TerminalException, MultipleExceptions
-from e2b.session.session_rpc import RpcException
+from pydantic import BaseModel
class TerminalOutput(BaseModel):
diff --git a/packages/python-sdk/e2b/session/websocket_client.py b/packages/python-sdk/e2b/session/websocket_client.py
new file mode 100644
index 000000000..2d2e27eae
--- /dev/null
+++ b/packages/python-sdk/e2b/session/websocket_client.py
@@ -0,0 +1,91 @@
+import asyncio
+import logging
+from queue import Queue
+from threading import Event
+from typing import Any, Callable, List
+
+from janus import SyncQueue as JanusQueue
+from websockets import WebSocketClientProtocol, connect
+from websockets.exceptions import ConnectionClosed
+from websockets.typing import Data
+
+logger = logging.getLogger(__name__)
+
+
+class WebSocket:
+ def __init__(
+ self,
+ url: str,
+ started: Event,
+ stopped: Event,
+ queue_in: Queue[dict],
+ queue_out: JanusQueue[Data],
+ ):
+ self._ws: WebSocketClientProtocol | None = None
+ self.url = url
+ self.started = started
+ self.stopped = stopped
+ self._process_cleanup: List[Callable[[], Any]] = []
+ self._queue_in = queue_in
+ self._queue_out = queue_out
+
+ async def run(self):
+ await self._connect()
+ await self.close()
+
+ async def _send_message(self):
+ logger.info("Starting to send messages")
+ while True:
+ if self._queue_in.empty():
+ await asyncio.sleep(0)
+ continue
+ message = self._queue_in.get()
+ logger.debug(f"Got message: {message}")
+ if self._ws:
+ await self._ws.send(message)
+ self._queue_in.task_done()
+ else:
+ logger.error("No websocket connection")
+
+ async def _receive_message(self):
+ try:
+ async for message in self._ws:
+ logger.debug(f"Received message: {message}")
+ self._queue_out.put(message)
+ except Exception as e:
+ logger.error(f"Error: {e}")
+
+ async def _connect(self):
+ async for websocket in connect(self.url, max_size=None, max_queue=None):
+ try:
+ self._ws = websocket
+ self.started.set()
+ logger.info(f"Connected to {self.url}")
+
+ send_task = asyncio.create_task(
+ self._send_message(), name="send_message"
+ )
+ self._process_cleanup.append(send_task.cancel)
+
+ receive_task = asyncio.create_task(
+ self._receive_message(), name="receive_message"
+ )
+ self._process_cleanup.append(receive_task.cancel)
+
+ while not self.stopped.is_set():
+ await asyncio.sleep(0)
+
+ logger.info("WebSocket stopped")
+ break
+ except ConnectionClosed:
+ logger.warning("Reconnecting...")
+ continue
+
+ async def close(self):
+ for cancel in self._process_cleanup:
+ cancel()
+
+ self._process_cleanup.clear()
+
+ if self._ws:
+ await self._ws.close()
diff --git a/packages/python-sdk/e2b/utils/future.py b/packages/python-sdk/e2b/utils/future.py
index cebf646bd..6125cbf8a 100644
--- a/packages/python-sdk/e2b/utils/future.py
+++ b/packages/python-sdk/e2b/utils/future.py
@@ -1,6 +1,5 @@
import asyncio
-
-from typing import Awaitable, TypeVar, Generic, List, Callable, Any, Optional
+from typing import Any, Awaitable, Callable, Generic, List, TypeVar
T = TypeVar("T")
@@ -29,11 +28,9 @@ class DeferredFuture(Generic[T]):
self._future.set_exception(reason)
-def run_async_func_in_new_loop(
- coro: Awaitable, loop: Optional[asyncio.AbstractEventLoop] = None
-):
+def run_async_func_in_new_loop(coro: Awaitable):
# Create a new loop
- loop = loop or asyncio.new_event_loop()
+ loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
diff --git a/packages/python-sdk/poetry.lock b/packages/python-sdk/poetry.lock
index 8e5c816f2..0553090f0 100644
--- a/packages/python-sdk/poetry.lock
+++ b/packages/python-sdk/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.5.1 and should not be changed by hand.
[[package]]
name = "aenum"
@@ -136,13 +136,13 @@ frozenlist = ">=1.1.0"
[[package]]
name = "async-timeout"
-version = "4.0.2"
+version = "4.0.3"
description = "Timeout context manager for asyncio programs"
optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.7"
files = [
- {file = "async-timeout-4.0.2.tar.gz", hash = "sha256:2163e1640ddb52b7a8c80d0a67a08587e5d245cc9c553a74a847056bc2976b15"},
- {file = "async_timeout-4.0.2-py3-none-any.whl", hash = "sha256:8ca1e4fcf50d07413d66d1a5e416e42cfdf5851c981d679a09851a6853383b3c"},
+ {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"},
+ {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"},
]
[[package]]
@@ -295,13 +295,13 @@ files = [
[[package]]
name = "click"
-version = "8.1.6"
+version = "8.1.7"
description = "Composable command line interface toolkit"
optional = false
python-versions = ">=3.7"
files = [
- {file = "click-8.1.6-py3-none-any.whl", hash = "sha256:fa244bb30b3b5ee2cae3da8f55c9e5e0c0e86093306301fb418eb9dc40fbded5"},
- {file = "click-8.1.6.tar.gz", hash = "sha256:48ee849951919527a045bfe3bf7baa8a959c423134e1a5b98c05c20ba75a1cbd"},
+ {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+ {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
]
[package.dependencies]
@@ -438,6 +438,20 @@ files = [
{file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
]
+[[package]]
+name = "janus"
+version = "1.0.0"
+description = "Mixed sync-async queue to interoperate between asyncio tasks and classic threads"
+optional = false
+python-versions = ">=3.7"
+files = [
+ {file = "janus-1.0.0-py3-none-any.whl", hash = "sha256:2596ea5482711c1ee3ef2df6c290aaf370a13c55a007826e8f7c32d696d1d00a"},
+ {file = "janus-1.0.0.tar.gz", hash = "sha256:df976f2cdcfb034b147a2d51edfc34ff6bfb12d4e2643d3ad0e10de058cb1612"},
+]
+
+[package.dependencies]
+typing-extensions = ">=3.7.4.3"
+
[[package]]
name = "jsonrpcclient"
version = "4.0.3"
@@ -942,4 +956,4 @@ multidict = ">=4.0"
[metadata]
lock-version = "2.0"
python-versions = "^3.9"
-content-hash = "320f4b57893215bf7a2352d4b65d8bac53298af96f1c37ecfd2a53f8df2d8a40"
+content-hash = "900fe366641e9fe15fbf5b5b61af36a99ad54c2a58d42ebccbf1a7968e8b950c"
diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.toml
index 22fd56daa..c1ce892bc 100644
--- a/packages/python-sdk/pyproject.toml
+++ b/packages/python-sdk/pyproject.toml
@@ -19,6 +19,7 @@ pydantic = "^1.10.5, <2"
aenum = ">=3.1.11"
websockets = "^11.0.3"
jsonrpcclient = "^4.0.3"
+janus = "^1.0.0"
[tool.poetry.group.dev.dependencies]
black = "^23.7.0"
diff --git a/packages/python-sdk/tests/test_filesystem.py b/packages/python-sdk/tests/test_filesystem.py
index c1d1fa852..a1b972fc9 100644
--- a/packages/python-sdk/tests/test_filesystem.py
+++ b/packages/python-sdk/tests/test_filesystem.py
@@ -65,7 +65,7 @@ async def test_watch_dir():
await sleep(1)
await watcher.stop()
- assert len(events) == 1
+ assert len(events) >= 1
event = events[0]
assert event["operation"] == "Write"