shellsim 0.1.15__tar.gz → 0.1.16__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.15"
+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.15 → shellsim-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.15
+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.15 → shellsim-0.1.16}/python/native/Cargo.lock

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

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

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

{shellsim-0.1.15 → 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.15 → 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.15 → shellsim-0.1.16}/src/python/stdlib/source/asyncio.py

@@ -232,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):
@@ -269,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):
@@ -704,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)
@@ -723,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
@@ -731,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
@@ -744,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:
@@ -752,9 +764,13 @@ 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 self._current is task:
+            task._must_cancel = True
+            return
         dependency = task._waiting_on
         if isinstance(dependency, (Task, Future)) and dependency.cancel():
             return
@@ -925,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():
@@ -1262,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.15 → 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.15 → 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;
                 }