shellsim 0.1.13__tar.gz → 0.1.15__tar.gz

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

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

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

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

{shellsim-0.1.13 → shellsim-0.1.15}/PKG-INFO

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

{shellsim-0.1.13 → shellsim-0.1.15}/python/native/Cargo.lock

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

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

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

{shellsim-0.1.13 → shellsim-0.1.15}/src/python/protocol.rs

@@ -20,6 +20,25 @@ pub fn display(heap: &Heap, value: &Value) -> Result<String, String> {
     if let Some((kind, message)) = exception_parts(heap, value)? {
         return Ok(if message.is_empty() { kind } else { message });
     }
+    if let Some((_, args)) = user_exception_parts(heap, value)? {
+        return match args.as_slice() {
+            [] => Ok(String::new()),
+            [only] => {
+                if let Some(value) = string_value(heap, only)? {
+                    Ok(value)
+                } else {
+                    repr(heap, only)
+                }
+            }
+            _ => {
+                let values = args
+                    .iter()
+                    .map(|value| repr(heap, value))
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(format!("({})", values.join(", ")))
+            }
+        };
+    }
     repr(heap, value)
 }
 
@@ -100,6 +119,41 @@ pub fn exception_parts(heap: &Heap, value: &Value) -> Result<Option<(String, Str
     })
 }
 
+fn user_exception_parts(
+    heap: &Heap,
+    value: &Value,
+) -> Result<Option<(String, Vec<Value>)>, String> {
+    let Some(id) = value.object_id() else {
+        return Ok(None);
+    };
+    let Object::Instance { class, .. } = heap.get(id)? else {
+        return Ok(None);
+    };
+    let Object::Class {
+        name,
+        exception_base,
+        ..
+    } = heap.get(*class)?
+    else {
+        return Ok(None);
+    };
+    if exception_base.is_none() {
+        return Ok(None);
+    }
+    let args = if let Some(symbol) = heap.symbol_id("args") {
+        heap.attribute_by_symbol(id, symbol)?
+            .and_then(|value| value.object_id())
+            .and_then(|args| match heap.get(args).ok()? {
+                Object::Tuple(values) => Some(values.clone()),
+                _ => None,
+            })
+            .unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+    Ok(Some((name.clone(), args)))
+}
+
 fn bigint_value<'a>(heap: &'a Heap, value: &Value) -> Option<&'a BigInt> {
     let id = value.object_id()?;
     match heap.get(id).ok()? {
@@ -244,6 +298,15 @@ fn render(heap: &Heap, value: &Value, active: &mut BTreeSet<ObjectId>) -> Result
             Object::Instance { class, payload, .. } => match payload {
                 InstancePayload::Int(value) => value.to_string(),
                 InstancePayload::Object => match heap.get(*class)? {
+                    Object::Class {
+                        name,
+                        exception_base: Some(_),
+                        ..
+                    } => {
+                        let (_, args) = user_exception_parts(heap, value)?
+                            .ok_or("exception instance lost its native base")?;
+                        format!("{name}({})", render_values(heap, &args, active)?.join(", "))
+                    }
                     Object::Class { name, .. } => format!("<{name} object>"),
                     _ => return Err("instance has an invalid class".into()),
                 },

{shellsim-0.1.13 → shellsim-0.1.15}/src/python/stdlib/source/asyncio.py

@@ -33,6 +33,40 @@ class QueueFull(Exception):
     pass
 
 
+class InvalidStateError(Exception):
+    pass
+
+
+class Handle:
+    def __init__(self, callback, args):
+        self._callback = callback
+        self._args = args
+        self._cancelled = False
+
+    def cancel(self):
+        self._cancelled = True
+
+    def cancelled(self):
+        return self._cancelled
+
+    def _run(self):
+        if self._cancelled:
+            return
+        try:
+            self._callback(*self._args)
+        except Exception:
+            pass
+
+
+class TimerHandle(Handle):
+    def __init__(self, when, callback, args):
+        Handle.__init__(self, callback, args)
+        self._when = when
+
+    def when(self):
+        return self._when
+
+
 class _Sleep:
     def __init__(self, delay):
         self.delay = delay
@@ -87,6 +121,100 @@ class _TimeoutWait:
         self.timed_out = False
 
 
+class Future:
+    def __init__(self, *, loop=None):
+        if loop is None:
+            loop = get_running_loop()
+        self._loop = loop
+        self._done = False
+        self._cancelled = False
+        self._result = None
+        self._exception = None
+        self._waiters = []
+        self._callbacks = []
+
+    def get_loop(self):
+        return self._loop
+
+    def done(self):
+        return self._done
+
+    def cancelled(self):
+        return self._cancelled
+
+    def result(self):
+        if not self._done:
+            raise InvalidStateError("Result is not ready")
+        if self._cancelled:
+            raise CancelledError()
+        if self._exception is not None:
+            raise self._exception
+        return self._result
+
+    def exception(self):
+        if not self._done:
+            raise InvalidStateError("Exception is not set")
+        if self._cancelled:
+            raise CancelledError()
+        return self._exception
+
+    def add_done_callback(self, callback, *, context=None):
+        if self._done:
+            self._loop.call_soon(callback, self)
+        else:
+            self._callbacks.append(callback)
+
+    def remove_done_callback(self, callback):
+        previous = len(self._callbacks)
+        self._callbacks = [item for item in self._callbacks if item is not callback]
+        return previous - len(self._callbacks)
+
+    def cancel(self, msg=None):
+        if self._done:
+            return False
+        self._done = True
+        self._cancelled = True
+        self._loop._run_done_callbacks(self)
+        self._loop._wake_waiters(self)
+        return True
+
+    def set_result(self, result):
+        if self._done:
+            raise InvalidStateError("invalid state")
+        self._done = True
+        self._result = result
+        self._loop._run_done_callbacks(self)
+        self._loop._wake_waiters(self)
+
+    def set_exception(self, exception):
+        if self._done:
+            raise InvalidStateError("invalid state")
+        if not isinstance(exception, BaseException):
+            raise TypeError("invalid exception object")
+        self._done = True
+        self._exception = exception
+        self._loop._run_done_callbacks(self)
+        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):
@@ -145,7 +273,7 @@ class Task:
 
     def add_done_callback(self, callback, context=None):
         if self._done:
-            callback(self)
+            self._loop.call_soon(callback, self)
         else:
             self._callbacks.append(callback)
 
@@ -583,6 +711,9 @@ class _Loop:
         self._ready.append(task)
         return task
 
+    def create_future(self):
+        return Future(loop=self)
+
     def _create_awaited_task(self, coroutine, parent):
         task = self.create_task(coroutine)
         task._logical_task = parent._logical_task
@@ -591,6 +722,22 @@ class _Loop:
     def time(self):
         return _monotonic_ns() / 1000000000
 
+    def call_soon(self, callback, *args, context=None):
+        handle = Handle(callback, args)
+        self._ready.append(handle)
+        return handle
+
+    def call_soon_threadsafe(self, callback, *args, context=None):
+        return self.call_soon(callback, *args, context=context)
+
+    def call_at(self, when, callback, *args, context=None):
+        handle = TimerHandle(when, callback, args)
+        self._timers.append((int(when * 1000000000), handle))
+        return handle
+
+    def call_later(self, delay, callback, *args, context=None):
+        return self.call_at(self.time() + delay, callback, *args, context=context)
+
     def _schedule(self, task, value):
         if not task._done:
             self._resource_waiters = [
@@ -608,6 +755,11 @@ class _Loop:
             self._ready.append(task)
 
     def _cancel(self, task):
+        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
             task._cancelled = True
@@ -627,11 +779,15 @@ class _Loop:
         now = _monotonic_ns()
         pending = []
         for timer_deadline, timer in self._timers:
+            if isinstance(timer, TimerHandle) and timer.cancelled():
+                continue
             if timer_deadline <= now:
                 if isinstance(timer, _TimeoutWait):
                     if timer.parent._waiting_on is timer:
                         timer.timed_out = True
                         timer.child.cancel()
+                elif isinstance(timer, TimerHandle):
+                    self._ready.append(timer)
                 else:
                     self._schedule(timer, None)
             else:
@@ -639,10 +795,15 @@ class _Loop:
         self._timers = pending
 
     def _next_timer_token(self):
-        if not self._timers:
+        active = [
+            item
+            for item in self._timers
+            if not isinstance(item[1], TimerHandle) or not item[1].cancelled()
+        ]
+        if not active:
             return None
-        deadline = self._timers[0][0]
-        for timer_deadline, timer in self._timers:
+        deadline = active[0][0]
+        for timer_deadline, timer in active:
             if timer_deadline < deadline:
                 deadline = timer_deadline
         return ("timer", deadline)
@@ -661,31 +822,38 @@ class _Loop:
         for task, token in waiters:
             self._schedule(task, None)
 
-    def _wake_waiters(self, task):
-        waiters = task._waiters
-        task._waiters = []
+    def _wake_waiters(self, future):
+        waiters = future._waiters
+        future._waiters = []
         for waiter in waiters:
             if isinstance(waiter, _TimeoutWait):
                 waiter.parent._waiting_on = None
                 if waiter.timed_out:
                     self._schedule_failure(waiter.parent, TimeoutError())
-                elif task._exception is not None:
-                    self._schedule_failure(waiter.parent, task._exception)
+                elif future._cancelled:
+                    self._schedule_failure(waiter.parent, CancelledError())
+                elif future._exception is not None:
+                    self._schedule_failure(waiter.parent, future._exception)
                 else:
-                    self._schedule(waiter.parent, task._result)
-            elif task._exception is not None:
-                self._schedule_failure(waiter, task._exception)
+                    self._schedule(waiter.parent, future._result)
+            elif future._cancelled:
+                if waiter._waiting_on is future:
+                    waiter._waiting_on = None
+                self._schedule_failure(waiter, CancelledError())
+            elif future._exception is not None:
+                if waiter._waiting_on is future:
+                    waiter._waiting_on = None
+                self._schedule_failure(waiter, future._exception)
             else:
-                self._schedule(waiter, task._result)
+                if waiter._waiting_on is future:
+                    waiter._waiting_on = None
+                self._schedule(waiter, future._result)
 
-    def _run_done_callbacks(self, task):
-        callbacks = task._callbacks
-        task._callbacks = []
+    def _run_done_callbacks(self, future):
+        callbacks = future._callbacks
+        future._callbacks = []
         for callback in callbacks:
-            try:
-                callback(task)
-            except Exception:
-                pass
+            self.call_soon(callback, future)
 
     def _finish(self, task, result):
         task._done = True
@@ -700,18 +868,21 @@ class _Loop:
         self._wake_waiters(task)
         self._run_done_callbacks(task)
 
-    def _block_on_task(self, task, awaited):
+    def _block_on_future(self, task, awaited):
         if awaited._done:
-            if awaited._exception is not None:
+            if awaited._cancelled:
+                self._schedule_failure(task, CancelledError())
+            elif awaited._exception is not None:
                 self._schedule_failure(task, awaited._exception)
             else:
                 self._schedule(task, awaited._result)
         else:
+            task._waiting_on = awaited
             awaited._waiters.append(task)
 
     def _dispatch_yield(self, task, awaited):
-        if isinstance(awaited, Task):
-            self._block_on_task(task, awaited)
+        if isinstance(awaited, (Task, Future)):
+            self._block_on_future(task, awaited)
         elif isinstance(awaited, _Sleep):
             self._sleep(task, awaited.delay)
         elif isinstance(awaited, _EventWait):
@@ -738,7 +909,7 @@ class _Loop:
             awaited.condition._waiters.append(task)
         elif isinstance(awaited, _WaitFor):
             if awaited.task._done:
-                self._block_on_task(task, awaited.task)
+                self._block_on_future(task, awaited.task)
             else:
                 timeout = _TimeoutWait(task, awaited.task)
                 task._waiting_on = timeout
@@ -749,7 +920,7 @@ class _Loop:
         elif isinstance(awaited, _ResourceWait):
             self._resource_waiters.append((task, awaited.token))
         elif _is_coroutine(awaited):
-            self._block_on_task(task, self._create_awaited_task(awaited, task))
+            self._block_on_future(task, self._create_awaited_task(awaited, task))
         else:
             raise TypeError("object cannot be used in 'await' expression")
 
@@ -761,6 +932,9 @@ class _Loop:
             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
@@ -783,6 +957,10 @@ def get_running_loop():
     return _running_loop
 
 
+def get_event_loop():
+    return get_running_loop()
+
+
 def create_task(coroutine, name=None, context=None):
     return get_running_loop().create_task(coroutine, name)
 
@@ -791,6 +969,10 @@ def ensure_future(awaitable):
     return _ensure_task(awaitable)
 
 
+def isfuture(value):
+    return isinstance(value, (Future, Task))
+
+
 def current_task(loop=None):
     if loop is None:
         loop = get_running_loop()
@@ -806,7 +988,7 @@ def all_tasks(loop=None):
 
 
 def _ensure_task(awaitable):
-    if isinstance(awaitable, Task):
+    if isinstance(awaitable, (Task, Future)):
         return awaitable
     return create_task(awaitable)
 
@@ -816,17 +998,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):
@@ -923,7 +1138,7 @@ async def wait(awaitables, timeout=None, return_when=ALL_COMPLETED):
     if not tasks:
         raise ValueError("Set of Tasks/Futures is empty")
     for task in tasks:
-        if not isinstance(task, Task):
+        if not isinstance(task, (Task, Future)):
             raise TypeError("Passing coroutines is forbidden, use tasks explicitly")
     changed = Event()
 
@@ -985,8 +1200,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,

{shellsim-0.1.13 → shellsim-0.1.15}/src/python/vm/calls.rs

@@ -200,6 +200,7 @@ impl Vm<'_> {
                     name,
                     metaclass,
                     layout,
+                    exception_base,
                     is_dataclass,
                     dataclass_fields,
                     enum_members,
@@ -339,6 +340,16 @@ impl Vm<'_> {
                         payload,
                         attributes: InstanceAttributes::default(),
                     })?;
+                    if exception_base.is_some() {
+                        let exception_args =
+                            self.allocate_object(Object::Tuple(arguments.clone()))?;
+                        self.state.heap.insert_attribute(
+                            instance.object_id().expect("instances are heap objects"),
+                            "args".into(),
+                            exception_args,
+                            &mut self.interp.resources,
+                        )?;
+                    }
                     if is_dataclass {
                         let mut values = Vec::new();
                         for (index, (field, default)) in dataclass_fields.iter().enumerate() {
@@ -428,7 +439,10 @@ impl Vm<'_> {
                                 unreachable!("immediate initializer cannot suspend")
                             }
                         }
+                    } else if exception_base.is_some() && !keyword_arguments.is_empty() {
+                        return Err(format!("{name}() does not accept keyword arguments"));
                     } else if layout == ClassLayout::Object
+                        && exception_base.is_none()
                         && (!arguments.is_empty() || !keyword_arguments.is_empty())
                     {
                         return Err(format!("{name}() takes no arguments"));