shellsim 0.1.14__tar.gz → 0.1.16__tar.gz

{shellsim-0.1.14 → shellsim-0.1.16}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.14 → shellsim-0.1.16}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.14"
+version = "0.1.16"
 edition = "2021"
 description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"

{shellsim-0.1.14 → shellsim-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.14
+Version: 0.1.16
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X

{shellsim-0.1.14 → shellsim-0.1.16}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.14 → shellsim-0.1.16}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.14"
+version = "0.1.16"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"

{shellsim-0.1.14 → shellsim-0.1.16}/src/python/compiler.rs

@@ -659,8 +659,6 @@ impl Compiler {
                     self.protected_regions.pop();
                     if let Some(handler_body_try) = handler_body_try {
                         self.emit(Operation::TryEnd, span);
-                        self.emit(Operation::ClearException, span);
-                        self.statements(finalbody.clone());
                         let handler_body_done = self.emit(Operation::Jump(usize::MAX), span);
                         let handler_body_cleanup = self.instructions.len();
                         self.patch_try_begin(handler_body_try, handler_body_cleanup);

{shellsim-0.1.14 → shellsim-0.1.16}/src/python/heap.rs

@@ -202,13 +202,14 @@ pub enum Object {
         exhausted: bool,
     },
     /// A suspended Python generator frame. The bytecode is immutable; the instruction pointer,
-    /// exception-handler stack, and lexical scope are the complete resumable state.
+    /// exception state, and lexical scope are the complete resumable state.
     Generator {
         name: String,
         code: CodeRef,
         scope: ScopeId,
         instruction_pointer: usize,
         handlers: Vec<(usize, usize)>,
+        exceptions: Vec<(String, Value)>,
         stack: Vec<Value>,
         exhausted: bool,
         running: bool,
@@ -1433,11 +1434,13 @@ fn trace_object(
         }
         Object::Generator {
             scope,
+            exceptions,
             stack,
             return_value,
             ..
         } => {
             scope_work.push(*scope);
+            trace_values(exceptions.iter().map(|(_, value)| *value), object_work);
             trace_values(stack.iter().copied(), object_work);
             trace_value(*return_value, object_work);
         }
@@ -1566,12 +1569,14 @@ fn modeled_size(object: &Object) -> Result<u64, String> {
             name,
             code,
             handlers,
+            exceptions,
             stack,
             ..
         } => name
             .len()
             .checked_add(code.instructions.len())
             .and_then(|size| size.checked_add(handlers.len()))
+            .and_then(|size| size.checked_add(exceptions.len()))
             .and_then(|size| size.checked_add(stack.len()))
             .ok_or("modeled object size overflow")?,
         Object::Module { name, .. } => name.len(),

{shellsim-0.1.14 → shellsim-0.1.16}/src/python/stdlib/source/asyncio.py

@@ -197,6 +197,24 @@ class Future:
         self._loop._wake_waiters(self)
 
 
+class _GatheringFuture(Future):
+    def __init__(self, children, *, loop):
+        Future.__init__(self, loop=loop)
+        self._children = children
+        self._cancel_requested = False
+
+    def cancel(self, msg=None):
+        if self._done:
+            return False
+        cancelled = False
+        for child in self._children:
+            if child.cancel(msg=msg):
+                cancelled = True
+        if cancelled:
+            self._cancel_requested = True
+        return cancelled
+
+
 class Task:
     def __init__(self, coroutine, loop, name=None):
         if not _is_coroutine(coroutine):
@@ -214,6 +232,7 @@ class Task:
         self._name = name
         self._callbacks = []
         self._cancel_requests = 0
+        self._must_cancel = False
         self._logical_task = self
 
     def done(self):
@@ -251,6 +270,8 @@ class Task:
     def uncancel(self):
         if self._cancel_requests:
             self._cancel_requests -= 1
+        if not self._cancel_requests:
+            self._must_cancel = False
         return self._cancel_requests
 
     def add_done_callback(self, callback, context=None):
@@ -686,8 +707,12 @@ class _Loop:
         self._resource_waiters = []
         self._tasks = []
         self._current = None
+        self._running = False
+        self._closed = False
 
     def create_task(self, coroutine, name=None):
+        if self._closed:
+            raise RuntimeError("Event loop is closed")
         task = Task(coroutine, self, name)
         self._tasks.append(task)
         self._ready.append(task)
@@ -705,6 +730,8 @@ class _Loop:
         return _monotonic_ns() / 1000000000
 
     def call_soon(self, callback, *args, context=None):
+        if self._closed:
+            raise RuntimeError("Event loop is closed")
         handle = Handle(callback, args)
         self._ready.append(handle)
         return handle
@@ -713,6 +740,8 @@ class _Loop:
         return self.call_soon(callback, *args, context=context)
 
     def call_at(self, when, callback, *args, context=None):
+        if self._closed:
+            raise RuntimeError("Event loop is closed")
         handle = TimerHandle(when, callback, args)
         self._timers.append((int(when * 1000000000), handle))
         return handle
@@ -726,7 +755,8 @@ class _Loop:
                 waiter for waiter in self._resource_waiters if waiter[0] is not task
             ]
             task._send_value = (True, value)
-            self._ready.append(task)
+            if task not in self._ready:
+                self._ready.append(task)
 
     def _schedule_failure(self, task, error):
         if not task._done:
@@ -734,10 +764,17 @@ class _Loop:
                 waiter for waiter in self._resource_waiters if waiter[0] is not task
             ]
             task._send_value = (False, error)
-            self._ready.append(task)
+            if task not in self._ready:
+                self._ready.append(task)
 
     def _cancel(self, task):
-        if isinstance(task._waiting_on, Future) and task._waiting_on.cancel():
+        if self._current is task:
+            task._must_cancel = True
+            return
+        dependency = task._waiting_on
+        if isinstance(dependency, (Task, Future)) and dependency.cancel():
+            return
+        if isinstance(dependency, _TimeoutWait) and dependency.child.cancel():
             return
         if not task._started:
             task._done = True
@@ -856,8 +893,7 @@ class _Loop:
             else:
                 self._schedule(task, awaited._result)
         else:
-            if isinstance(awaited, Future):
-                task._waiting_on = awaited
+            task._waiting_on = awaited
             awaited._waiters.append(task)
 
     def _dispatch_yield(self, task, awaited):
@@ -905,30 +941,83 @@ class _Loop:
             raise TypeError("object cannot be used in 'await' expression")
 
     def run(self, coroutine):
+        if self._closed:
+            raise RuntimeError("Event loop is closed")
+        if self._running:
+            raise RuntimeError("This event loop is already running")
         root = self.create_task(coroutine)
-        while not root.done():
-            if not self._ready:
-                self._wake_due_timers()
-            if not self._ready:
-                self._wait_for_resources()
-            task = self._ready.pop(0)
-            if isinstance(task, Handle):
-                task._run()
-                continue
-            if task._done:
-                continue
-            task._started = True
-            self._current = task
-            status, value = _step(task._coroutine, task._send_value)
+        self._running = True
+        try:
+            while not root.done():
+                if not self._ready:
+                    self._wake_due_timers()
+                if not self._ready:
+                    self._wait_for_resources()
+                task = self._ready.pop(0)
+                if isinstance(task, Handle):
+                    task._run()
+                    continue
+                if task._done:
+                    continue
+                task._started = True
+                self._current = task
+                status, value = _step(task._coroutine, task._send_value)
+                self._current = None
+                task._send_value = None
+                if status == 1:
+                    self._finish(task, value)
+                elif status == 2:
+                    self._fail(task, value)
+                elif task._must_cancel:
+                    task._must_cancel = False
+                    self._schedule_failure(task, CancelledError())
+                else:
+                    self._dispatch_yield(task, value)
+            return root.result()
+        finally:
             self._current = None
-            task._send_value = None
-            if status == 1:
-                self._finish(task, value)
-            elif status == 2:
-                self._fail(task, value)
-            else:
-                self._dispatch_yield(task, value)
-        return root.result()
+            self._running = False
+
+    def run_until_complete(self, awaitable):
+        async def wait_for_awaitable():
+            return await awaitable
+
+        return self.run(wait_for_awaitable())
+
+    def is_running(self):
+        return self._running
+
+    def is_closed(self):
+        return self._closed
+
+    async def shutdown_asyncgens(self):
+        return None
+
+    async def shutdown_default_executor(self, timeout=None):
+        return None
+
+    def _shutdown(self):
+        pending = [task for task in self._tasks if not task.done()]
+        if not pending:
+            return
+        for task in pending:
+            task.cancel()
+
+        async def wait_for_pending():
+            await gather(*pending, return_exceptions=True)
+
+        self.run(wait_for_pending())
+
+    def close(self):
+        if self._running:
+            raise RuntimeError("Cannot close a running event loop")
+        if self._closed:
+            return
+        self._closed = True
+        self._ready = []
+        self._timers = []
+        self._resource_waiters = []
+        self._tasks = []
 
 
 def get_running_loop():
@@ -978,17 +1067,50 @@ async def sleep(delay, result=None):
     return result
 
 
-async def gather(*coroutines, return_exceptions=False):
+def gather(*coroutines, return_exceptions=False):
     tasks = [_ensure_task(coroutine) for coroutine in coroutines]
-    results = []
+    observed = []
     for task in tasks:
-        try:
-            results.append(await task)
-        except Exception as error:
+        if task not in observed:
+            observed.append(task)
+    loop = get_running_loop()
+    outer = _GatheringFuture(observed, loop=loop)
+    if not tasks:
+        outer.set_result([])
+        return outer
+
+    results = [None for task in tasks]
+    completed = [False for task in tasks]
+
+    def child_completed(child):
+        if outer.done():
+            return
+        if outer._cancel_requested:
+            if all(task.done() for task in observed):
+                outer.set_exception(CancelledError())
+            return
+        if child.cancelled():
+            if not return_exceptions:
+                outer.set_exception(CancelledError())
+                return
+            result = CancelledError()
+        elif child.exception() is not None:
             if not return_exceptions:
-                raise
-            results.append(error)
-    return results
+                outer.set_exception(child.exception())
+                return
+            result = child.exception()
+        else:
+            result = child.result()
+        for index in range(len(tasks)):
+            if tasks[index] is child:
+                completed[index] = True
+                results[index] = result
+        if all(completed):
+            outer.set_result(results)
+
+    for task in observed:
+        task.add_done_callback(child_completed)
+    return outer
 
 
 async def wait_for(awaitable, timeout):
@@ -1147,8 +1269,24 @@ def as_completed(awaitables, timeout=None):
         yield next_result()
 
 
-async def shield(awaitable):
-    return await _ensure_task(awaitable)
+def shield(awaitable):
+    inner = _ensure_task(awaitable)
+    if inner.done():
+        return inner
+    outer = get_running_loop().create_future()
+
+    def inner_completed(completed):
+        if outer.done():
+            return
+        if completed.cancelled():
+            outer.cancel()
+        elif completed.exception() is not None:
+            outer.set_exception(completed.exception())
+        else:
+            outer.set_result(completed.result())
+
+    inner.add_done_callback(inner_completed)
+    return outer
 
 
 async def create_subprocess_exec(program, *args, stdin=None, stdout=None, stderr=None,
@@ -1193,4 +1331,10 @@ def run(coroutine):
     try:
         return loop.run(coroutine)
     finally:
-        _running_loop = None
+        try:
+            loop._shutdown()
+            loop.run(loop.shutdown_asyncgens())
+            loop.run(loop.shutdown_default_executor())
+        finally:
+            loop.close()
+            _running_loop = None

{shellsim-0.1.14 → shellsim-0.1.16}/src/python/vm/calls.rs

@@ -1179,6 +1179,7 @@ impl Vm<'_> {
             scope,
             instruction_pointer: 0,
             handlers: Vec::new(),
+            exceptions: Vec::new(),
             stack: Vec::new(),
             exhausted: false,
             running: false,

{shellsim-0.1.14 → shellsim-0.1.16}/src/python/vm/iteration.rs

@@ -274,28 +274,38 @@ impl Vm<'_> {
         if self.call_depth >= MAX_GENERATOR_DEPTH {
             return Err("maximum recursion depth exceeded".into());
         }
-        let (code, scope, instruction_pointer, mut handlers, frame_stack, exhausted, running) =
-            match self.state.heap.get(id)?.clone() {
-                Object::Generator {
-                    code,
-                    scope,
-                    instruction_pointer,
-                    handlers,
-                    stack,
-                    exhausted,
-                    running,
-                    ..
-                } => (
-                    code,
-                    scope,
-                    instruction_pointer,
-                    handlers,
-                    stack,
-                    exhausted,
-                    running,
-                ),
-                _ => return Err("object is not a generator".into()),
-            };
+        let (
+            code,
+            scope,
+            instruction_pointer,
+            mut handlers,
+            exceptions,
+            frame_stack,
+            exhausted,
+            running,
+        ) = match self.state.heap.get(id)?.clone() {
+            Object::Generator {
+                code,
+                scope,
+                instruction_pointer,
+                handlers,
+                exceptions,
+                stack,
+                exhausted,
+                running,
+                ..
+            } => (
+                code,
+                scope,
+                instruction_pointer,
+                handlers,
+                exceptions,
+                stack,
+                exhausted,
+                running,
+            ),
+            _ => return Err("object is not a generator".into()),
+        };
         if exhausted {
             return Ok(None);
         }
@@ -313,11 +323,20 @@ impl Vm<'_> {
         if instruction_pointer != 0 {
             self.stack.push(sent);
         }
+        let generator_exceptions = exceptions
+            .into_iter()
+            .map(|(kind, value)| super::RaisedException { kind, value })
+            .collect();
+        let outer_exceptions = std::mem::replace(&mut self.exception_stack, generator_exceptions);
         self.local_scopes.push(scope);
         self.call_depth += 1;
         let result = self.execute_code_from(&code, instruction_pointer, &mut handlers, 0);
         self.call_depth -= 1;
         self.local_scopes.pop();
+        let generator_exceptions = std::mem::replace(&mut self.exception_stack, outer_exceptions)
+            .into_iter()
+            .map(|exception| (exception.kind, exception.value))
+            .collect();
         let frame_result_stack = std::mem::take(&mut self.stack);
         self.stack = outer_stack;
 
@@ -328,6 +347,7 @@ impl Vm<'_> {
                 if let Object::Generator {
                     instruction_pointer,
                     handlers: saved_handlers,
+                    exceptions: saved_exceptions,
                     stack: saved_stack,
                     running,
                     ..
@@ -335,6 +355,7 @@ impl Vm<'_> {
                 {
                     *instruction_pointer = next_instruction;
                     *saved_handlers = handlers;
+                    *saved_exceptions = generator_exceptions;
                     *saved_stack = frame_result_stack;
                     *running = false;
                 }