shellsim 0.1.10__tar.gz → 0.1.12__tar.gz

{shellsim-0.1.10 → shellsim-0.1.12}/Cargo.lock

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

{shellsim-0.1.10 → shellsim-0.1.12}/Cargo.toml

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

{shellsim-0.1.10 → shellsim-0.1.12}/PKG-INFO

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

{shellsim-0.1.10 → shellsim-0.1.12}/python/native/Cargo.lock

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

{shellsim-0.1.10 → shellsim-0.1.12}/python/native/Cargo.toml

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

{shellsim-0.1.10 → shellsim-0.1.12}/src/descriptors.rs

@@ -194,6 +194,34 @@ impl DescriptorArena {
         })
     }
 
+    /// Whether retrying a blocked input read can now make progress.
+    pub(crate) fn input_readable(&self, id: DescriptionId) -> bool {
+        self.descriptions
+            .get(&id)
+            .is_some_and(|entry| match &entry.description {
+                OpenDescription::Input {
+                    bytes,
+                    cursor,
+                    closed,
+                } => *cursor < bytes.len() || *closed,
+                _ => false,
+            })
+    }
+
+    /// Whether retrying a blocked pipe read can now return bytes or EOF.
+    pub(crate) fn pipe_readable(&self, id: PipeId) -> bool {
+        self.pipes
+            .get(&id)
+            .is_some_and(|pipe| !pipe.bytes.is_empty() || pipe.writers == 0)
+    }
+
+    /// Whether retrying a blocked pipe write can now write or report a closed reader.
+    pub(crate) fn pipe_writable(&self, id: PipeId) -> bool {
+        self.pipes
+            .get(&id)
+            .is_some_and(|pipe| pipe.readers == 0 || pipe.bytes.len() < pipe.capacity)
+    }
+
     /// Append explicitly supplied bytes to a streaming input description.
     pub fn append_input(&mut self, id: DescriptionId, input: &[u8]) -> Result<(), DescriptorError> {
         let entry = self

{shellsim-0.1.10 → shellsim-0.1.12}/src/exec.rs

@@ -405,7 +405,7 @@ enum ExpansionLocation {
     Redirect(usize),
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum ShellPoll {
     Pending,
     Blocked(crate::scheduler::WaitReason),
@@ -2507,21 +2507,13 @@ fn handle_ready_events(interp: &mut Interp) -> Result<(), String> {
                     continue;
                 };
                 let deadline = event.id.deadline_ns();
-                let timed_wait = matches!(
-                    interp.scheduler.state(pid),
-                    Some(crate::scheduler::TaskState::Blocked(
-                        crate::scheduler::WaitReason::Timer(value)
-                            | crate::scheduler::WaitReason::ChildDeadline(_, value)
-                            | crate::scheduler::WaitReason::ChildActivityDeadline(_, value)
-                    ))
-                        | Some(crate::scheduler::TaskState::Stopped(
-                            crate::scheduler::StoppedTask::Blocked(
-                                crate::scheduler::WaitReason::Timer(value)
-                                    | crate::scheduler::WaitReason::ChildDeadline(_, value)
-                                    | crate::scheduler::WaitReason::ChildActivityDeadline(_, value)
-                            )
-                        )) if value == deadline
-                );
+                let timed_wait = match interp.scheduler.state(pid) {
+                    Some(crate::scheduler::TaskState::Blocked(reason))
+                    | Some(crate::scheduler::TaskState::Stopped(
+                        crate::scheduler::StoppedTask::Blocked(reason),
+                    )) => reason.accepts_timer(deadline),
+                    _ => false,
+                };
                 if timed_wait {
                     interp
                         .scheduler

{shellsim-0.1.10 → shellsim-0.1.12}/src/harness.rs

@@ -304,7 +304,7 @@ pub enum ProcessViewStatus {
 }
 
 /// Serializable scheduler wait reason without exposing implementation strings.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum WaitReasonView {
     Timer { deadline_ns: u64 },
@@ -315,6 +315,7 @@ pub enum WaitReasonView {
     ChildActivity { pid: u32 },
     ChildDeadline { pid: u32, deadline_ns: u64 },
     ChildActivityDeadline { pid: u32, deadline_ns: u64 },
+    Any { reasons: Vec<WaitReasonView> },
 }
 
 /// One stable path-level difference from the last checkpoint.
@@ -1259,6 +1260,9 @@ fn wait_reason_view(reason: WaitReason) -> WaitReasonView {
         WaitReason::ChildActivityDeadline(pid, deadline_ns) => {
             WaitReasonView::ChildActivityDeadline { pid, deadline_ns }
         }
+        WaitReason::Any(reasons) => WaitReasonView::Any {
+            reasons: reasons.into_iter().map(wait_reason_view).collect(),
+        },
     }
 }
 

{shellsim-0.1.10 → shellsim-0.1.12}/src/python/native.rs

@@ -81,7 +81,7 @@ impl fmt::Debug for ValueKindDef {
 }
 
 /// Stable error categories produced by native Python operations.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(super) enum PyErrorKind {
     Type,
     Value,
@@ -298,6 +298,12 @@ pub(super) struct PyProcessOutput {
     pub inherited_stderr: Vec<u8>,
 }
 
+/// Result of probing a modeled process operation without driving the scheduler.
+pub(super) enum PyProcessPoll<T> {
+    Ready(T),
+    Blocked(crate::scheduler::WaitReason),
+}
+
 /// Fully-owned request for a child that outlives the native launch call.
 pub(super) struct PyProcessStartRequest {
     pub argv: Vec<String>,
@@ -339,8 +345,19 @@ pub(super) trait PyProcessRunner {
         fd: i32,
         amount: Option<usize>,
     ) -> PyResult<Vec<u8>>;
+    fn try_read_pipe(
+        &mut self,
+        handle: PyProcessHandle,
+        fd: i32,
+        amount: Option<usize>,
+    ) -> PyResult<PyProcessPoll<Vec<u8>>>;
     /// Write bytes to a captured child stdin, cooperatively scheduling while the pipe is full.
     fn write_pipe(&mut self, handle: PyProcessHandle, input: Vec<u8>) -> PyResult<usize>;
+    fn try_write_pipe(
+        &mut self,
+        handle: PyProcessHandle,
+        input: Vec<u8>,
+    ) -> PyResult<PyProcessPoll<usize>>;
     /// Close one parent-side captured stream endpoint.
     fn close_pipe(&mut self, handle: PyProcessHandle, fd: i32) -> PyResult<()>;
     fn send_signal(
@@ -557,6 +574,8 @@ pub(super) trait PyRuntime {
     fn exception_type_name(&self, value: &PyValue) -> Option<&'static str>;
     /// Return one interpreter-owned exception class from the runtime's closed type table.
     fn exception_type(&self, name: &'static str) -> PyValue;
+    /// Suspend the enclosing logical process until any modeled resource becomes ready.
+    fn wait_on(&mut self, reasons: Vec<crate::scheduler::WaitReason>) -> PyResult<()>;
     fn clock(&mut self) -> &mut dyn PyClock;
     fn environment(&self) -> &dyn PyEnvironment;
     fn filesystem(&mut self) -> &mut dyn PyFilesystem;

shellsim-0.1.12/src/python/stdlib/asyncio.rs

@@ -0,0 +1,232 @@
+//! VM primitives used by the deterministic `asyncio` compatibility module.
+//!
+//! Scheduling policy stays in frozen Python. This module exposes bounded coroutine stepping and
+//! checked waits on virtual time and modeled process resources. It cannot acquire host threads,
+//! clocks, processes, files, or network access.
+
+use super::super::native::{
+    CallArgs, FunctionDef, ModuleDef, PyError, PyIterator, PyKind, PyList, PyProcessHandle,
+    PyProcessPoll, PyResult, PyRuntime, PyTuple, PyValueCast,
+};
+use super::super::Value;
+
+pub(super) static MODULE: ModuleDef = ModuleDef {
+    name: "_asyncio",
+    functions: &[
+        FunctionDef {
+            module: "_asyncio",
+            name: "_step",
+            call: step,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_is_coroutine",
+            call: is_coroutine,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_monotonic_ns",
+            call: monotonic_ns,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_wait_resources",
+            call: wait_resources,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_process_poll",
+            call: process_poll,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_process_read",
+            call: process_read,
+        },
+        FunctionDef {
+            module: "_asyncio",
+            name: "_process_write",
+            call: process_write,
+        },
+    ],
+    values: &[],
+};
+
+fn step(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._step", 2, 2)?;
+    args.reject_keywords("_asyncio._step")?;
+    let coroutine = args.positional()[0];
+    if runtime.kind(&coroutine)? != PyKind::Generator {
+        return Err(PyError::type_error("expected a coroutine"));
+    }
+    let iterator = coroutine.cast::<PyIterator>(runtime)?;
+    let sent = args.positional()[1];
+    let (status, value) = runtime.coroutine_step(iterator, sent)?;
+    runtime.new_tuple(vec![Value::Int(i64::from(status)), value])
+}
+
+fn is_coroutine(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._is_coroutine", 1, 1)?;
+    args.reject_keywords("_asyncio._is_coroutine")?;
+    Ok(Value::Bool(
+        runtime.kind(&args.positional()[0])? == PyKind::Generator,
+    ))
+}
+
+fn monotonic_ns(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._monotonic_ns", 0, 0)?;
+    args.reject_keywords("_asyncio._monotonic_ns")?;
+    runtime.clock().monotonic_ns().map(Value::Int)
+}
+
+fn wait_resources(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._wait_resources", 1, 1)?;
+    args.reject_keywords("_asyncio._wait_resources")?;
+    let tokens = args.positional()[0].cast::<PyList>(runtime)?;
+    let tokens = runtime.list_items(tokens)?;
+    if tokens.len() > crate::scheduler::MAX_TASKS {
+        return Err(PyError::resource_error("too many asyncio resource waits"));
+    }
+    let mut reasons = Vec::with_capacity(tokens.len());
+    for token in tokens {
+        runtime.charge_cpu(1)?;
+        reasons.push(parse_wait_token(runtime, token)?);
+    }
+    runtime.wait_on(reasons)?;
+    Ok(Value::None)
+}
+
+fn process_poll(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._process_poll", 1, 1)?;
+    args.reject_keywords("_asyncio._process_poll")?;
+    let handle = process_handle(runtime, args.positional()[0])?;
+    Ok(runtime
+        .processes()
+        .poll(handle)?
+        .map_or(Value::None, |status| Value::Int(i64::from(status))))
+}
+
+fn process_read(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._process_read", 3, 3)?;
+    args.reject_keywords("_asyncio._process_read")?;
+    let values = args.positional();
+    let handle = process_handle(runtime, values[0])?;
+    let fd = integer(runtime, values[1], "stream descriptor")?;
+    let fd = i32::try_from(fd).map_err(|_| PyError::value_error("invalid stream descriptor"))?;
+    let amount = integer(runtime, values[2], "read size")?;
+    let amount = if amount < 0 {
+        None
+    } else {
+        Some(
+            usize::try_from(amount)
+                .map_err(|_| PyError::overflow_error("read size is too large"))?,
+        )
+    };
+    match runtime.processes().try_read_pipe(handle, fd, amount)? {
+        PyProcessPoll::Ready(bytes) => {
+            let bytes = runtime.new_bytes(bytes)?;
+            poll_tuple(runtime, true, bytes, Value::None)
+        }
+        PyProcessPoll::Blocked(reason) => {
+            let token = wait_token(runtime, reason)?;
+            poll_tuple(runtime, false, Value::None, token)
+        }
+    }
+}
+
+fn process_write(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("_asyncio._process_write", 2, 2)?;
+    args.reject_keywords("_asyncio._process_write")?;
+    let values = args.positional();
+    let handle = process_handle(runtime, values[0])?;
+    let input = runtime
+        .bytes_value(&values[1])?
+        .ok_or_else(|| PyError::type_error("process input must be bytes"))?;
+    match runtime.processes().try_write_pipe(handle, input)? {
+        PyProcessPoll::Ready(written) => {
+            let written = i64::try_from(written)
+                .map_err(|_| PyError::overflow_error("write result is too large"))?;
+            poll_tuple(runtime, true, Value::Int(written), Value::None)
+        }
+        PyProcessPoll::Blocked(reason) => {
+            let token = wait_token(runtime, reason)?;
+            poll_tuple(runtime, false, Value::None, token)
+        }
+    }
+}
+
+fn poll_tuple(runtime: &mut dyn PyRuntime, ready: bool, value: Value, token: Value) -> PyResult {
+    runtime.new_tuple(vec![Value::Bool(ready), value, token])
+}
+
+fn process_handle(runtime: &dyn PyRuntime, value: Value) -> PyResult<PyProcessHandle> {
+    let pid = integer(runtime, value, "subprocess handle")?;
+    let pid = u32::try_from(pid).map_err(|_| PyError::value_error("invalid subprocess handle"))?;
+    Ok(PyProcessHandle { pid })
+}
+
+fn integer(runtime: &dyn PyRuntime, value: Value, name: &str) -> PyResult<i64> {
+    runtime
+        .int_value(&value)
+        .ok_or_else(|| PyError::type_error(format!("{name} must be an integer")))
+}
+
+fn parse_wait_token(
+    runtime: &mut dyn PyRuntime,
+    token: Value,
+) -> PyResult<crate::scheduler::WaitReason> {
+    let token = token.cast::<PyTuple>(runtime)?;
+    let parts = runtime.tuple_items(token)?;
+    if parts.len() != 2 {
+        return Err(PyError::value_error("invalid asyncio resource token"));
+    }
+    let kind = runtime
+        .string_value(&parts[0])?
+        .ok_or_else(|| PyError::type_error("asyncio resource kind must be a string"))?;
+    let value = integer(runtime, parts[1], "asyncio resource identifier")?;
+    match kind.as_str() {
+        "timer" => u64::try_from(value)
+            .map(crate::scheduler::WaitReason::Timer)
+            .map_err(|_| PyError::value_error("invalid timer deadline")),
+        "input_readable" => u32::try_from(value)
+            .map(crate::scheduler::WaitReason::InputReadable)
+            .map_err(|_| PyError::value_error("invalid input descriptor")),
+        "pipe_readable" => u32::try_from(value)
+            .map(crate::scheduler::WaitReason::PipeReadable)
+            .map_err(|_| PyError::value_error("invalid pipe identifier")),
+        "pipe_writable" => u32::try_from(value)
+            .map(crate::scheduler::WaitReason::PipeWritable)
+            .map_err(|_| PyError::value_error("invalid pipe identifier")),
+        "child" => u32::try_from(value)
+            .map(crate::scheduler::WaitReason::Child)
+            .map_err(|_| PyError::value_error("invalid child identifier")),
+        "child_activity" => u32::try_from(value)
+            .map(crate::scheduler::WaitReason::ChildActivity)
+            .map_err(|_| PyError::value_error("invalid child identifier")),
+        _ => Err(PyError::value_error("unsupported asyncio resource kind")),
+    }
+}
+
+fn wait_token(runtime: &mut dyn PyRuntime, reason: crate::scheduler::WaitReason) -> PyResult {
+    let (kind, value) = match reason {
+        crate::scheduler::WaitReason::Timer(value) => ("timer", u64_to_i64(value)?),
+        crate::scheduler::WaitReason::InputReadable(value) => ("input_readable", i64::from(value)),
+        crate::scheduler::WaitReason::PipeReadable(value) => ("pipe_readable", i64::from(value)),
+        crate::scheduler::WaitReason::PipeWritable(value) => ("pipe_writable", i64::from(value)),
+        crate::scheduler::WaitReason::Child(value) => ("child", i64::from(value)),
+        crate::scheduler::WaitReason::ChildActivity(value) => ("child_activity", i64::from(value)),
+        crate::scheduler::WaitReason::ChildDeadline(_, _)
+        | crate::scheduler::WaitReason::ChildActivityDeadline(_, _)
+        | crate::scheduler::WaitReason::Any(_) => {
+            return Err(PyError::runtime_error(
+                "unsupported nested asyncio resource wait",
+            ))
+        }
+    };
+    let kind = runtime.new_string(kind.to_string())?;
+    runtime.new_tuple(vec![kind, Value::Int(value)])
+}
+
+fn u64_to_i64(value: u64) -> PyResult<i64> {
+    i64::try_from(value).map_err(|_| PyError::overflow_error("timer deadline is too large"))
+}