Skip to content

armgit / E2B

Public Imported from GitHub
0

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

Improve close handling; Refresh session in separate thread; Keep websocket alive in a separate thread; Bump version

Tomas Valenta8bd1c93b3f23
diff --git a/packages/python-sdk/e2b/session/main.py b/packages/python-sdk/e2b/session/main.py
index 663d2c6f7..b8f71e12f 100644
--- a/packages/python-sdk/e2b/session/main.py
+++ b/packages/python-sdk/e2b/session/main.py
@@ -93,6 +93,7 @@ class Session(SessionConnection):
_debug_hostname=_debug_hostname,
_debug_port=_debug_port,
_debug_dev_env=_debug_dev_env,
+ on_close=self._close_services,
)
self._code_snippet = CodeSnippetManager(
session=self,
@@ -106,10 +107,20 @@ class Session(SessionConnection):
await super().open()
await self._code_snippet._subscribe()
- async def close(self) -> None:
+ def _close_services(self):
self._terminal._close()
self._process._close()
+
+ async def close(self) -> None:
await super().close()
+ self._close()
+
+ async def __aenter__(self):
+ await self.open()
+ return self
+
+ async def __aexit__(self, exc_type, exc_value, traceback):
+ await self.close()
@classmethod
async def create(
diff --git a/packages/python-sdk/e2b/session/process.py b/packages/python-sdk/e2b/session/process.py
index cd48be057..36857f334 100644
--- a/packages/python-sdk/e2b/session/process.py
+++ b/packages/python-sdk/e2b/session/process.py
@@ -178,9 +178,6 @@ class ProcessManager:
self._session = session
self._process_cleanup: List[Callable[[], Any]] = []
- def __del__(self):
- self._close()
-
def _close(self):
for cleanup in self._process_cleanup:
cleanup()
diff --git a/packages/python-sdk/e2b/session/session_connection.py b/packages/python-sdk/e2b/session/session_connection.py
index 6699134d8..d91b0e92e 100644
--- a/packages/python-sdk/e2b/session/session_connection.py
+++ b/packages/python-sdk/e2b/session/session_connection.py
@@ -1,15 +1,19 @@
import asyncio
+from concurrent.futures import ThreadPoolExecutor
import logging
import traceback
-from typing import Awaitable, Literal, Optional, Callable, List, Any, Coroutine
+from typing import Awaitable, Literal, Optional, Callable, List, Any
from pydantic import BaseModel
+
+from e2b.api.client.rest import ApiException
from e2b.session.exception import MultipleExceptions, SessionException
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.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,
@@ -28,6 +32,8 @@ class Subscription(BaseModel):
class SessionConnection:
+ _refresh_retries = 4
+
@property
def finished(self):
"""
@@ -53,6 +59,7 @@ class SessionConnection:
_debug_hostname: Optional[str] = None,
_debug_port: Optional[int] = None,
_debug_dev_env: Optional[Literal["remote", "local"]] = None,
+ on_close: Optional[Callable[[], Any]] = None,
):
self._id = id
self._api_key = api_key
@@ -60,11 +67,12 @@ class SessionConnection:
self._debug_port = _debug_port
self._debug_dev_env = _debug_dev_env
self._edit_enabled = edit_enabled
+ self._on_close_child = on_close
self._session: Optional[SessionInfo] = None
self._is_open = False
self._process_cleanup: List[Callable[[], Any]] = []
- self._refreshing_task: Optional[asyncio.Task] = None
+ self._refreshing_task: Optional[asyncio.Future] = None
self._subscribers = {}
self._rpc: SessionRpc
self._finished = DeferredFuture(self._process_cleanup)
@@ -80,7 +88,9 @@ class SessionConnection:
:return: hostname of the session or session's port
"""
if not self._session:
- raise Exception("Session is not running. You have to run `await session.open()` first or create the session with `await Session.create()")
+ raise Exception(
+ "Session is not running. You have to run `await session.open()` first or create the session with `await Session.create()"
+ )
if self._debug_hostname:
if port and self._debug_dev_env == "remote":
@@ -101,18 +111,18 @@ class SessionConnection:
"""
Close the session and unsubscribe from all the subscriptions.
"""
- self._close()
-
if self._is_open:
logger.info(f"Closing session {self._session}")
self._is_open = False
if self._rpc:
await self._rpc.close()
- def __del__(self):
self._close()
def _close(self):
+ if self._on_close_child:
+ self._on_close_child()
+
self._subscribers.clear()
for cleanup in self._process_cleanup:
@@ -138,13 +148,40 @@ class SessionConnection:
NewSession(codeSnippetID=self._id, editEnabled=self._edit_enabled),
)
logger.info(f"Acquired session: {self._session}")
- self._session.session_id
- self._refreshing_task = asyncio.create_task(
- self._refresh(self._session.session_id)
+
+ # We could potentially use asyncio.to_thread() but that requires Python 3.9+
+ executor = ThreadPoolExecutor()
+ self._refreshing_task = asyncio.get_running_loop().run_in_executor(
+ executor,
+ run_async_func_in_new_loop,
+ self._refresh(self._session.session_id),
)
+
self._process_cleanup.append(self._refreshing_task.cancel)
+ self._process_cleanup.append(
+ lambda: executor.shutdown(wait=False, cancel_futures=True)
+ )
+
+ async def refresh_cleanup():
+ try:
+ if self._refreshing_task:
+ await self._refreshing_task
+ finally:
+ if self._session:
+ logger.info(
+ f"Stopped refreshing session {self._session.session_id}"
+ )
+ else:
+ logger.info(
+ f"No session to stop refreshing. Session was not created"
+ )
+
+ await self.close()
+
+ refresh_handler = asyncio.create_task(refresh_cleanup())
+ self._process_cleanup.append(refresh_handler.cancel)
except Exception as e:
- logger.info(f"Failed to acquire session: {e}")
+ logger.error(f"Failed to acquire session: {e}")
raise e
hostname = self.get_hostname(self._debug_port or WS_PORT)
@@ -160,13 +197,12 @@ class SessionConnection:
)
await self._rpc.connect()
except Exception as e:
- logger.info(e)
raise e
async def _call(self, service: str, method: str, params: List[Any] = []):
if not self.is_open:
raise SessionException("Session is not open")
-
+
return await self._rpc.send_message(f"{service}_{method}", params)
async def _handle_subscriptions(
@@ -202,8 +238,8 @@ class SessionConnection:
for i, s in enumerate(exceptions):
tb = s.__traceback__ # Get the traceback object
- stack_trace = '\n'.join(traceback.extract_tb(tb).format())
- error_message += f"\n[{i}]: {type(s).__name__}(\"{s}\"):\n{stack_trace}\n"
+ stack_trace = "\n".join(traceback.extract_tb(tb).format())
+ error_message += f'\n[{i}]: {type(s).__name__}("{s}"):\n{stack_trace}\n'
raise MultipleExceptions(
message=error_message,
@@ -250,24 +286,37 @@ class SessionConnection:
async def _refresh(self, session_id: str):
logger.info(f"Started refreshing session {session_id}")
- try:
- async with client.ApiClient(configuration) as api_client:
- api = client.SessionsApi(api_client)
- while True:
- if not self._is_open:
- logger.info(
- f"Cannot refresh session - it was closed. {self._session}"
- )
- return
- await asyncio.sleep(SESSION_REFRESH_PERIOD)
- try:
- await api.sessions_session_id_refresh_post(
- session_id,
- )
- logger.info(f"Refreshed session {session_id}")
- except Exception as e:
- logger.info(e)
- logger.info(f"Refreshing session {session_id} failed")
- finally:
- logger.info(f"Stopped refreshing session {session_id}")
- await self.close()
+
+ current_retry = 0
+
+ async with client.ApiClient(configuration) as api_client:
+ api = client.SessionsApi(api_client)
+ while True:
+ if not self._is_open:
+ logger.info(
+ f"Cannot refresh session - it was closed. {self._session}"
+ )
+ return
+ await asyncio.sleep(SESSION_REFRESH_PERIOD)
+ try:
+ await api.sessions_session_id_refresh_post(
+ session_id,
+ )
+ logger.info(f"Refreshed session {session_id}")
+ except ApiException as e:
+ if e.status == 404:
+ logger.error(f"Session {session_id} not found {e}")
+ raise SessionException(
+ f"Session {session_id} failed because it cannot be found"
+ ) from e
+ else:
+ if current_retry < self._refresh_retries:
+ logger.error(
+ f"Refreshing session {session_id} failed. Retrying..."
+ )
+ current_retry += 1
+ else:
+ logger.error(
+ f"Refreshing session {session_id} failed. Max retries exceeded"
+ )
+ raise e
diff --git a/packages/python-sdk/e2b/session/session_rpc.py b/packages/python-sdk/e2b/session/session_rpc.py
index 64839ec1e..c7df75fca 100644
--- a/packages/python-sdk/e2b/session/session_rpc.py
+++ b/packages/python-sdk/e2b/session/session_rpc.py
@@ -2,6 +2,7 @@ import asyncio
import json
import logging
+from threading import Event
from websockets.client import WebSocketClientProtocol, connect
from typing import (
Callable,
@@ -18,8 +19,9 @@ from jsonrpcclient import request_json, Ok
from jsonrpcclient.id_generators import decimal as decimal_id_generator
from jsonrpcclient.responses import Response, Error, Deserialized
from websockets.typing import Data
-from e2b.session.exception import SessionException
+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__)
@@ -97,8 +99,32 @@ class SessionRpc(BaseModel):
future_connect = DeferredFuture(self._process_cleanup)
async def handle_messages():
- async for websocket in connect(self.url):
+ async for websocket in connect(
+ self.url,
+ ping_interval=None,
+ ping_timeout=None,
+ max_queue=None,
+ max_size=None,
+ ):
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:
@@ -133,7 +159,7 @@ class SessionRpc(BaseModel):
logger.info(f"Received reply: {r}")
return r
except Exception as e:
- logger.info(f"Error: {request} {e}")
+ logger.error(f"Error: {request} {e}")
raise e
finally:
del self._waiting_for_replies[id]
@@ -168,9 +194,6 @@ class SessionRpc(BaseModel):
elif isinstance(message, Notification):
self.on_message(message)
- def __del__(self):
- self._close()
-
def _close(self):
for cancel in self._process_cleanup:
cancel()
@@ -182,6 +205,7 @@ class SessionRpc(BaseModel):
del handler
async def close(self):
+ print("cancelling")
self._close()
if self._ws:
diff --git a/packages/python-sdk/e2b/session/terminal.py b/packages/python-sdk/e2b/session/terminal.py
index fc530e899..61732cab0 100644
--- a/packages/python-sdk/e2b/session/terminal.py
+++ b/packages/python-sdk/e2b/session/terminal.py
@@ -124,9 +124,6 @@ class TerminalManager:
self._session = session
self._process_cleanup: List[Callable[[], Any]] = []
- def __del__(self):
- self._close()
-
def _close(self):
for cleanup in self._process_cleanup:
cleanup()
diff --git a/packages/python-sdk/e2b/utils/future.py b/packages/python-sdk/e2b/utils/future.py
index 984502b8d..cebf646bd 100644
--- a/packages/python-sdk/e2b/utils/future.py
+++ b/packages/python-sdk/e2b/utils/future.py
@@ -1,11 +1,11 @@
import asyncio
-import json
-from typing import TypeVar, Generic, List, Callable, Any
+from typing import Awaitable, TypeVar, Generic, List, Callable, Any, Optional
T = TypeVar("T")
+# Check if using event is not better for most use cases
class DeferredFuture(Generic[T]):
def __init__(self, cleanup_list: List[Callable[[], Any]] | None = None):
self._future = asyncio.Future[T]()
@@ -29,10 +29,14 @@ class DeferredFuture(Generic[T]):
self._future.set_exception(reason)
-def format_settled_errors(settled: List[Exception]):
- errors = "errors:\n"
- for i, s in enumerate(settled):
- if s is Exception:
- errors += f"\n[{i}]: {json.dumps(s.exception().__str__())}"
+def run_async_func_in_new_loop(
+ coro: Awaitable, loop: Optional[asyncio.AbstractEventLoop] = None
+):
+ # Create a new loop
+ loop = loop or asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
- return errors
+ try:
+ return loop.run_until_complete(coro)
+ finally:
+ loop.close()
diff --git a/packages/python-sdk/poetry.lock b/packages/python-sdk/poetry.lock
index 3c5a0266a..3ac0d086d 100644
--- a/packages/python-sdk/poetry.lock
+++ b/packages/python-sdk/poetry.lock
@@ -852,5 +852,5 @@ multidict = ">=4.0"
[metadata]
lock-version = "2.0"
-python-versions = "^3.8"
-content-hash = "41f37a0d6416abca8a05729bb7b1422d3245b6ebd007f58da229c3a401833fd4"
+python-versions = "^3.9"
+content-hash = "7caac35a1b837b2d3d661b79a168519c4e60c4490f2ec9b7e9194ab1beb66bf6"
diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.toml
index 960b3a3c6..4b3d311bf 100644
--- a/packages/python-sdk/pyproject.toml
+++ b/packages/python-sdk/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "e2b"
-version = "0.1.7"
+version = "0.1.9"
description = "E2B SDK that give agents cloud environments"
authors = ["e2b <[email protected]>"]
license = "MIT"
@@ -10,7 +10,7 @@ repository = "https://github.com/e2b-dev/e2b/tree/main/packages/python-sdk"
packages = [{ include = "e2b" }]
[tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
urllib3 = ">= 1.25.3"
python-dateutil = ">=2.8.2"