shellsim 0.1.18__tar.gz → 0.1.19__tar.gz

{shellsim-0.1.18 → shellsim-0.1.19}/Cargo.lock

@@ -861,7 +861,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.18 → shellsim-0.1.19}/Cargo.toml

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

{shellsim-0.1.18 → shellsim-0.1.19}/PKG-INFO

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

{shellsim-0.1.18 → shellsim-0.1.19}/python/native/Cargo.lock

@@ -925,7 +925,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "base64",
  "crc32fast",
@@ -947,7 +947,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.18"
+version = "0.1.19"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.18 → shellsim-0.1.19}/python/native/Cargo.toml

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

{shellsim-0.1.18 → shellsim-0.1.19}/src/interp.rs

@@ -162,7 +162,7 @@ pub struct ProcessState {
     pub session_id: ProcessId,
     /// Process group inherited across ordinary forks or established by a group leader.
     pub process_group: ProcessId,
-    /// PID expanded by `$$`; preserved across Bash subshells.
+    /// PID expanded by `$$`; preserved across Bash subshells and reset when a shell image loads.
     pub shell_pid: ProcessId,
     /// shell + environment variables (we don't distinguish exported vs not for simplicity,
     /// except that `env`/child python only sees exported ones, tracked in `exported`)
@@ -1102,6 +1102,17 @@ impl Environment {
         state.command_hash.clear();
         state.directory_stack.clear();
         state.local_scopes.clear();
+        // The new image is a fresh shell: `$$` names it, and loop, job, and getopts state from
+        // the forked parent shell do not carry over.
+        state.shell_pid = pid;
+        state.jobs.clear();
+        state.next_job_id = 1;
+        state.loop_depth = 0;
+        state.cond_depth = 0;
+        state.getopts = GetoptsState {
+            optind: 1,
+            offset: 1,
+        };
         state.arg0 = image.arg0;
         state.positional = image.positional;
         state.opt_errexit = image.errexit;

{shellsim-0.1.18 → shellsim-0.1.19}/src/python/parser.rs

@@ -2101,6 +2101,26 @@ mod tests {
         parse(lex("sys.stdout.write(sys.argv[1])").unwrap()).unwrap();
     }
 
+    #[test]
+    fn parses_comma_separated_imports_and_rejects_a_missing_module() {
+        let program = parse(lex("import math, urllib.error as errors, random").unwrap()).unwrap();
+        let StatementKind::Import { modules } = &program.statements[0].kind else {
+            panic!("expected import statement")
+        };
+        assert_eq!(
+            modules,
+            &[
+                ("math".into(), "math".into()),
+                ("urllib.error".into(), "errors".into()),
+                ("random".into(), "random".into())
+            ]
+        );
+        for source in ["import math,", "import , math"] {
+            let error = parse(lex(source).unwrap()).expect_err("missing module must fail");
+            assert!(error.message.contains("expected a module name"));
+        }
+    }
+
     #[test]
     fn parses_tuple_subscripts_and_rejects_empty_tuple_members() {
         parse(lex("pair = values[1, 2]\nsingle = values[1,]").unwrap()).unwrap();

{shellsim-0.1.18 → shellsim-0.1.19}/src/python/protocol.rs

@@ -17,8 +17,8 @@ pub fn display(heap: &Heap, value: &Value) -> Result<String, String> {
     if let Some(value) = string_value(heap, value)? {
         return Ok(value);
     }
-    if let Some((kind, message)) = exception_parts(heap, value)? {
-        return Ok(if message.is_empty() { kind } else { message });
+    if let Some((_, message)) = exception_parts(heap, value)? {
+        return Ok(message);
     }
     if let Some((_, args)) = user_exception_parts(heap, value)? {
         return match args.as_slice() {

{shellsim-0.1.18 → shellsim-0.1.19}/src/python/stdlib/core.rs

@@ -19,6 +19,7 @@ use super::super::number::PyNumber;
 use super::super::slice::SlicePlan;
 
 static BUILTINS: &[FunctionDef] = &[
+    builtin("__import__", builtin_import),
     builtin("map", builtin_map),
     builtin("filter", builtin_filter),
     builtin("reversed", builtin_reversed),
@@ -2899,3 +2900,35 @@ fn slot_sequence_multiply(
         _ => unreachable!("only concrete sequence slots call this helper"),
     }
 }
+
+/// Import only through the simulated module loader, preserving dotted-import return behavior.
+fn builtin_import(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("__import__", 1, 5)?;
+    args.reject_unknown_keywords("__import__", &["globals", "locals", "fromlist", "level"])?;
+    let OwnedPyString(name) = args.positional()[0].cast(runtime)?;
+    let level = args
+        .positional()
+        .get(4)
+        .copied()
+        .or(args.keyword("__import__", "level")?.copied());
+    if let Some(level) = level {
+        if !matches!(
+            integer_argument(runtime, &level, "level must be an integer")?,
+            IntegerArgument::Finite(0)
+        ) {
+            return Err(PyError::value_error("relative __import__ is not supported"));
+        }
+    }
+    let fromlist = args
+        .positional()
+        .get(3)
+        .copied()
+        .or(args.keyword("__import__", "fromlist")?.copied());
+    let module = runtime.import_module(&name)?;
+    if let Some(fromlist) = fromlist {
+        if runtime.truth(&fromlist)? {
+            return Ok(module);
+        }
+    }
+    runtime.import_module(name.split('.').next().unwrap_or(&name))
+}

{shellsim-0.1.18 → shellsim-0.1.19}/src/python/stdlib/math.rs

@@ -45,6 +45,11 @@ pub(super) static MODULE: ModuleDef = ModuleDef {
             name: "ceil",
             call: native_ceil,
         },
+        FunctionDef {
+            module: "math",
+            name: "comb",
+            call: native_comb,
+        },
         FunctionDef {
             module: "math",
             name: "cos",
@@ -195,6 +200,44 @@ fn native_ceil(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "ceil")
 }
 
+/// Compute exact combinations with work and result storage bounded before multiplication.
+fn native_comb(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    args.expect_positional("math.comb", 2, 2)?;
+    args.reject_keywords("math.comb")?;
+    let n = integer_argument(runtime, &args.positional()[0], "comb")?;
+    let k = integer_argument(runtime, &args.positional()[1], "comb")?;
+    if n.is_negative() {
+        return Err(PyError::value_error("n must be a non-negative integer"));
+    }
+    if k.is_negative() {
+        return Err(PyError::value_error("k must be a non-negative integer"));
+    }
+    if k > n {
+        return runtime.new_integer("0");
+    }
+    let complement = &n - &k;
+    let selected = if k <= complement { k } else { complement };
+    let count = selected
+        .to_usize()
+        .ok_or_else(|| PyError::resource_error("combination length is too large"))?;
+    if count > 100_000 {
+        return Err(PyError::resource_error("combination length is too large"));
+    }
+    if count == 0 {
+        return runtime.new_integer("1");
+    }
+    let bytes = bigint_bytes(&n)?
+        .checked_mul(count.saturating_add(1))
+        .ok_or_else(|| PyError::resource_error("combination result is too large"))?;
+    runtime.reserve_memory(bytes)?;
+    let mut result = BigInt::from(1_u8);
+    for index in 1..=count {
+        runtime.charge_cpu(result.bits().div_ceil(64).saturating_add(1))?;
+        result = result * (&n - &selected + index) / index;
+    }
+    runtime.new_integer(&result.to_string())
+}
+
 fn native_cos(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "cos")
 }

{shellsim-0.1.18 → shellsim-0.1.19}/src/python/stdlib/source/random.py

@@ -11,6 +11,7 @@ class Random:
         if not isinstance(value, int):
             raise TypeError("shellsim random seeds must be integers or None")
         self._state = value % 2147483648
+        self._gauss_next = None
 
     def _next(self):
         self._state = (self._state * 1103515245 + 12345) % 2147483648
@@ -40,6 +41,18 @@ class Random:
     def uniform(self, left, right):
         return left + (right - left) * self.random()
 
+    def gauss(self, mu=0.0, sigma=1.0):
+        import math
+
+        value = self._gauss_next
+        self._gauss_next = None
+        if value is None:
+            angle = math.tau * self.random()
+            radius = math.sqrt(-2.0 * math.log(1.0 - self.random()))
+            value = math.cos(angle) * radius
+            self._gauss_next = math.sin(angle) * radius
+        return mu + value * sigma
+
     def choice(self, population):
         if len(population) == 0:
             raise IndexError("cannot choose from an empty sequence")
@@ -85,6 +98,10 @@ def uniform(left, right):
     return _default.uniform(left, right)
 
 
+def gauss(mu=0.0, sigma=1.0):
+    return _default.gauss(mu, sigma)
+
+
 def choice(population):
     return _default.choice(population)
 

shellsim-0.1.19/src/python/vm/format.rs

@@ -0,0 +1,352 @@
+//! Python's format-specification mini-language for f-strings, `format`, and `str.format`.
+//!
+//! A specification is parsed once into [`FormatSpec`], then rendered for an integer, float, or
+//! string. The supported grammar is `[align][sign][#][0][width][,][.precision][type]` with the
+//! default space fill. Custom fill characters, `=` alignment, the space sign, `_` grouping, and
+//! the `n`/`c` presentations are rejected explicitly rather than approximated.
+
+use super::BigInt;
+use num_bigint::Sign;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Align {
+    Left,
+    Right,
+    Center,
+}
+
+/// A parsed format specification. Widths and precisions are bounded by the caller's resource
+/// reservation before rendering allocates padding.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(super) struct FormatSpec {
+    pub(super) align: Option<Align>,
+    pub(super) plus: bool,
+    pub(super) alternate: bool,
+    pub(super) zero: bool,
+    pub(super) width: usize,
+    pub(super) grouping: bool,
+    pub(super) precision: Option<usize>,
+    pub(super) presentation: Option<char>,
+}
+
+impl FormatSpec {
+    /// Parse `spec`, for example `">+12,.2f"` or `"#010x"`.
+    pub(super) fn parse(spec: &str) -> Result<Self, String> {
+        let unsupported = || format!("unsupported format specification {spec:?}");
+        let mut parsed = Self::default();
+        let mut rest = spec;
+        if let Some(align) = rest.chars().next().and_then(|first| match first {
+            '<' => Some(Align::Left),
+            '>' => Some(Align::Right),
+            '^' => Some(Align::Center),
+            _ => None,
+        }) {
+            parsed.align = Some(align);
+            rest = &rest[1..];
+        }
+        if let Some(stripped) = rest.strip_prefix('+') {
+            parsed.plus = true;
+            rest = stripped;
+        } else if let Some(stripped) = rest.strip_prefix('-') {
+            rest = stripped;
+        }
+        if let Some(stripped) = rest.strip_prefix('#') {
+            parsed.alternate = true;
+            rest = stripped;
+        }
+        if let Some(stripped) = rest.strip_prefix('0') {
+            parsed.zero = true;
+            rest = stripped;
+        }
+        let (width, stripped) = leading_number(rest).map_err(|_| unsupported())?;
+        parsed.width = width.unwrap_or(0);
+        rest = stripped;
+        if let Some(stripped) = rest.strip_prefix(',') {
+            parsed.grouping = true;
+            rest = stripped;
+        }
+        if let Some(stripped) = rest.strip_prefix('.') {
+            let (precision, stripped) = leading_number(stripped).map_err(|_| unsupported())?;
+            parsed.precision = Some(precision.ok_or_else(unsupported)?);
+            rest = stripped;
+        }
+        let mut chars = rest.chars();
+        parsed.presentation = chars.next();
+        if chars.next().is_some() {
+            return Err(unsupported());
+        }
+        Ok(parsed)
+    }
+
+    fn sign(&self, negative: bool) -> &'static str {
+        if negative {
+            "-"
+        } else if self.plus {
+            "+"
+        } else {
+            ""
+        }
+    }
+
+    /// Pad a rendered number. Zero padding goes between the sign and the digits, and explicit
+    /// alignment takes precedence over it, as in CPython.
+    fn pad_number(&self, sign: &str, body: String) -> String {
+        let body = if self.grouping {
+            group_decimal(&body, self.zero_width(sign.len()))
+        } else {
+            body
+        };
+        let rendered = format!("{sign}{body}");
+        if self.align.is_none() && self.zero {
+            let padding = self.width.saturating_sub(rendered.len());
+            return format!("{sign}{}{body}", "0".repeat(padding));
+        }
+        align(&rendered, self.width, self.align.unwrap_or(Align::Right))
+    }
+
+    /// The minimum grouped digit-field width when zero padding applies.
+    fn zero_width(&self, sign: usize) -> usize {
+        if self.zero && self.align.is_none() {
+            self.width.saturating_sub(sign)
+        } else {
+            0
+        }
+    }
+}
+
+fn leading_number(text: &str) -> Result<(Option<usize>, &str), std::num::ParseIntError> {
+    let digits = text.bytes().take_while(u8::is_ascii_digit).count();
+    if digits == 0 {
+        return Ok((None, text));
+    }
+    Ok((Some(text[..digits].parse()?), &text[digits..]))
+}
+
+/// Format an integer with the `d`, `b`, `o`, `x`, `X`, or default presentation.
+pub(super) fn format_integer(value: BigInt, spec: &FormatSpec) -> Result<String, String> {
+    if spec.precision.is_some() {
+        return Err("precision is not allowed in integer format".into());
+    }
+    let (radix, prefix, uppercase) = match spec.presentation {
+        None | Some('d') => (10, "", false),
+        Some('b') => (2, "0b", false),
+        Some('o') => (8, "0o", false),
+        Some('x') => (16, "0x", false),
+        Some('X') => (16, "0X", true),
+        Some(other) => return Err(format!("unsupported integer format type {other:?}")),
+    };
+    if spec.alternate && radix == 10 {
+        return Err("alternate form is not allowed for decimal integers".into());
+    }
+    if spec.grouping && radix != 10 {
+        return Err("comma grouping requires decimal presentation".into());
+    }
+    let negative = value.sign() == Sign::Minus;
+    let magnitude = if negative { -value } else { value };
+    let mut digits = magnitude.to_str_radix(radix);
+    if uppercase {
+        digits.make_ascii_uppercase();
+    }
+    let prefix = if spec.alternate { prefix } else { "" };
+    if !prefix.is_empty() && spec.zero && spec.align.is_none() {
+        let content = spec.sign(negative).len() + prefix.len() + digits.len();
+        let padding = spec.width.saturating_sub(content);
+        return Ok(format!(
+            "{}{prefix}{}{digits}",
+            spec.sign(negative),
+            "0".repeat(padding)
+        ));
+    }
+    Ok(spec.pad_number(spec.sign(negative), format!("{prefix}{digits}")))
+}
+
+/// Format a float with the `f`, `e`, `E`, `g`, `G`, `%`, or default presentation. `repr` is
+/// Python's shortest round-trip text, used when neither a presentation nor a precision is given.
+pub(super) fn format_float(value: f64, repr: &str, spec: &FormatSpec) -> Result<String, String> {
+    if spec.alternate {
+        return Err("alternate form is not supported for floats".into());
+    }
+    let precision = spec.precision.unwrap_or(6);
+    let magnitude = value.abs();
+    let body = match spec.presentation {
+        _ if !value.is_finite() => non_finite(value, spec.presentation),
+        Some('f') => format!("{magnitude:.precision$}"),
+        Some('e') => scientific(magnitude, precision, 'e'),
+        Some('E') => scientific(magnitude, precision, 'E'),
+        Some('g') => format_general(magnitude, precision, false, false),
+        Some('G') => format_general(magnitude, precision, false, true),
+        Some('%') => format!("{:.precision$}%", magnitude * 100.0),
+        None => match spec.precision {
+            Some(precision) => format_general(magnitude, precision, true, false),
+            None => repr.trim_start_matches('-').to_string(),
+        },
+        Some(other) => return Err(format!("unsupported floating-point format type {other:?}")),
+    };
+    let body = match spec.presentation {
+        Some('%') if !value.is_finite() => format!("{body}%"),
+        _ => body,
+    };
+    Ok(spec.pad_number(spec.sign(value.is_sign_negative()), body))
+}
+
+/// Format a string with the `s` or default presentation.
+pub(super) fn format_text(value: &str, spec: &FormatSpec) -> Result<String, String> {
+    if spec.plus || spec.alternate || spec.zero || spec.grouping || spec.precision.is_some() {
+        return Err("numeric format options are not allowed for strings".into());
+    }
+    if !matches!(spec.presentation, None | Some('s')) {
+        return Err(format!(
+            "unsupported string format type {:?}",
+            spec.presentation.unwrap_or_default()
+        ));
+    }
+    Ok(align(value, spec.width, spec.align.unwrap_or(Align::Left)))
+}
+
+fn non_finite(value: f64, presentation: Option<char>) -> String {
+    let label = if value.is_nan() { "nan" } else { "inf" };
+    if matches!(presentation, Some('E' | 'G')) {
+        label.to_uppercase()
+    } else {
+        label.into()
+    }
+}
+
+fn scientific(value: f64, precision: usize, marker: char) -> String {
+    let rendered = format!("{value:.precision$e}");
+    let (mantissa, exponent) = rendered.split_once('e').expect("Rust scientific format");
+    let exponent = exponent.parse::<i32>().expect("Rust scientific exponent");
+    format!("{mantissa}{marker}{exponent:+03}")
+}
+
+/// Format significant digits of a nonnegative finite value using Python's fixed/scientific
+/// thresholds. The default presentation keeps a trailing `.0` and switches to scientific one
+/// digit earlier than `g`.
+fn format_general(value: f64, precision: usize, default_type: bool, uppercase: bool) -> String {
+    let precision = precision.max(1);
+    let decimals = precision.saturating_sub(1);
+    let scientific = format!("{value:.decimals$e}");
+    let (mantissa, exponent) = scientific.split_once('e').expect("Rust scientific format");
+    let exponent = exponent.parse::<i32>().expect("Rust scientific exponent");
+    let threshold = if default_type {
+        precision.saturating_sub(1)
+    } else {
+        precision
+    };
+    let use_scientific = exponent < -4 || usize::try_from(exponent).is_ok_and(|e| e >= threshold);
+    if use_scientific {
+        let mantissa = trim_fraction(mantissa, false);
+        return format!(
+            "{mantissa}{}{exponent:+03}",
+            if uppercase { 'E' } else { 'e' }
+        );
+    }
+    let decimals = usize::try_from(precision as i128 - i128::from(exponent) - 1)
+        .expect("fixed precision is nonnegative");
+    trim_fraction(&format!("{value:.decimals$}"), default_type)
+}
+
+fn trim_fraction(value: &str, preserve_decimal: bool) -> String {
+    let Some((integer, fraction)) = value.split_once('.') else {
+        return value.to_string();
+    };
+    let fraction = fraction.trim_end_matches('0');
+    if fraction.is_empty() {
+        if preserve_decimal {
+            format!("{integer}.0")
+        } else {
+            integer.to_string()
+        }
+    } else {
+        format!("{integer}.{fraction}")
+    }
+}
+
+/// Insert thousands separators in the leading digits of an unsigned `body`, first zero-filling
+/// those digits until the grouped field reaches `minimum` characters. As in CPython, a separator
+/// can make the result one character wider than `minimum`.
+fn group_decimal(body: &str, minimum: usize) -> String {
+    let digits = body.bytes().take_while(u8::is_ascii_digit).count();
+    if digits == 0 {
+        return body.into();
+    }
+    let rest = &body[digits..];
+    let mut filled = digits;
+    while filled + (filled - 1) / 3 + rest.len() < minimum {
+        filled += 1;
+    }
+    let padded = format!("{}{}", "0".repeat(filled - digits), &body[..digits]);
+    let mut result = String::with_capacity(filled + filled / 3 + rest.len());
+    for (index, digit) in padded.chars().enumerate() {
+        if index > 0 && (filled - index).is_multiple_of(3) {
+            result.push(',');
+        }
+        result.push(digit);
+    }
+    result.push_str(rest);
+    result
+}
+
+fn align(value: &str, width: usize, alignment: Align) -> String {
+    let padding = width.saturating_sub(value.chars().count());
+    let left = match alignment {
+        Align::Right => padding,
+        Align::Center => padding / 2,
+        Align::Left => 0,
+    };
+    let right = padding - left;
+    format!("{}{}{}", " ".repeat(left), value, " ".repeat(right))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn float(value: f64, spec: &str) -> String {
+        format_float(value, &value.to_string(), &FormatSpec::parse(spec).unwrap()).unwrap()
+    }
+
+    fn integer(value: i64, spec: &str) -> Result<String, String> {
+        format_integer(value.into(), &FormatSpec::parse(spec)?)
+    }
+
+    #[test]
+    fn parses_every_supported_field() {
+        assert_eq!(
+            FormatSpec::parse(">+#012,.3f").unwrap(),
+            FormatSpec {
+                align: Some(Align::Right),
+                plus: true,
+                alternate: true,
+                zero: true,
+                width: 12,
+                grouping: true,
+                precision: Some(3),
+                presentation: Some('f'),
+            }
+        );
+        for invalid in ["*<5", "1,,.2", "5.2ff", ".f", " d"] {
+            assert!(FormatSpec::parse(invalid).is_err(), "{invalid}");
+        }
+    }
+
+    #[test]
+    fn grouping_zero_fills_before_inserting_separators() {
+        assert_eq!(float(-1234.5, "+12,.2f"), "   -1,234.50");
+        assert_eq!(float(1234.0, "012,.0f"), "0,000,001,234");
+        assert_eq!(float(12345.0, ",.0"), "1e+04");
+        assert_eq!(integer(1234, "+012,d").unwrap(), "+000,001,234");
+        assert_eq!(integer(-1234567, ",").unwrap(), "-1,234,567");
+        assert!(integer(42, ",x").is_err());
+    }
+
+    #[test]
+    fn percent_and_signs_match_python() {
+        assert_eq!(float(0.125, ".1%"), "12.5%");
+        assert_eq!(float(-0.5, "+08.1%"), "-0050.0%");
+        assert_eq!(float(f64::INFINITY, "+%"), "+inf%");
+        assert_eq!(float(f64::NAN, "E"), "NAN");
+        assert_eq!(integer(255, "#06x").unwrap(), "0x00ff");
+        assert_eq!(integer(5, "^+5").unwrap(), " +5  ");
+    }
+}