superacli 1.1.6 → 1.1.7

package/ref-monty/crates/monty/src/io.rs

@@ -1,106 +0,0 @@
-use std::borrow::Cow;
-
-use crate::exception_public::MontyException;
-
-/// Output handler for the `print()` builtin function.
-///
-/// Provides common output modes as enum variants to avoid trait object overhead
-/// in the typical cases (stdout, disabled, collect). For custom output handling,
-/// use the `Callback` variant with a [`PrintWriterCallback`] implementation.
-///
-/// # Variants
-/// - `Disabled` - Silently discards all output (useful for benchmarking or suppressing output)
-/// - `Stdout` - Writes to standard output (the default behavior)
-/// - `Collect` - Accumulates output into a target `String` for programmatic access
-/// - `Callback` - Delegates to a user-provided [`PrintWriterCallback`] implementation
-pub enum PrintWriter<'a> {
-    /// Silently discard all output.
-    Disabled,
-    /// Write to standard output.
-    Stdout,
-    /// Collect all output into a string.
-    Collect(&'a mut String),
-    /// Delegate to a custom callback.
-    Callback(&'a mut dyn PrintWriterCallback),
-}
-
-impl PrintWriter<'_> {
-    /// Creates a new `PrintWriter` that reborrows the same underlying target.
-    ///
-    /// This is useful in iterative execution (`start`/`resume` loops) where each
-    /// step takes `PrintWriter` by value but you want all steps to write to the
-    /// same output target. The original writer remains valid after the reborrowed
-    /// copy is dropped.
-    pub fn reborrow(&mut self) -> PrintWriter<'_> {
-        match self {
-            Self::Disabled => PrintWriter::Disabled,
-            Self::Stdout => PrintWriter::Stdout,
-            Self::Collect(buf) => PrintWriter::Collect(buf),
-            Self::Callback(cb) => PrintWriter::Callback(&mut **cb),
-        }
-    }
-
-    /// Called once for each formatted argument passed to `print()`.
-    ///
-    /// This method writes only the given argument's text, without adding
-    /// separators or a trailing newline. Separators (spaces) and the final
-    /// terminator (newline) are emitted via [`stdout_push`](Self::stdout_push).
-    pub fn stdout_write(&mut self, output: Cow<'_, str>) -> Result<(), MontyException> {
-        match self {
-            Self::Disabled => Ok(()),
-            Self::Stdout => {
-                print!("{output}");
-                Ok(())
-            }
-            Self::Collect(buf) => {
-                buf.push_str(&output);
-                Ok(())
-            }
-            Self::Callback(cb) => cb.stdout_write(output),
-        }
-    }
-
-    /// Appends a single character to the output.
-    ///
-    /// Generally called to add spaces (separators) and newlines (terminators)
-    /// within print output.
-    pub fn stdout_push(&mut self, end: char) -> Result<(), MontyException> {
-        match self {
-            Self::Disabled => Ok(()),
-            Self::Stdout => {
-                print!("{end}");
-                Ok(())
-            }
-            Self::Collect(buf) => {
-                buf.push(end);
-                Ok(())
-            }
-            Self::Callback(cb) => cb.stdout_push(end),
-        }
-    }
-}
-
-/// Trait for custom output handling from the `print()` builtin function.
-///
-/// Implement this trait and pass it via [`PrintWriter::Callback`] to capture
-/// or redirect print output from sandboxed Python code.
-pub trait PrintWriterCallback {
-    /// Called once for each formatted argument passed to `print()`.
-    ///
-    /// This method is responsible for writing only the given argument's text, and must
-    /// not add separators or a trailing newline. Separators (such as spaces) and the
-    /// final terminator (such as a newline) are emitted via [`stdout_push`](Self::stdout_push).
-    ///
-    /// # Arguments
-    /// * `output` - The formatted output string for a single argument (without
-    ///   separators or trailing newline).
-    fn stdout_write(&mut self, output: Cow<'_, str>) -> Result<(), MontyException>;
-
-    /// Add a single character to stdout.
-    ///
-    /// Generally called to add spaces and newlines within print output.
-    ///
-    /// # Arguments
-    /// * `end` - The character to print after the formatted output.
-    fn stdout_push(&mut self, end: char) -> Result<(), MontyException>;
-}

package/ref-monty/crates/monty/src/lib.rs

@@ -1,52 +0,0 @@
-#![doc = include_str!("../../../README.md")]
-// first to include defer_drop macro
-mod heap_traits;
-
-mod args;
-mod asyncio;
-mod builtins;
-mod bytecode;
-mod exception_private;
-mod exception_public;
-mod expressions;
-mod fstring;
-mod function;
-mod heap;
-mod heap_data;
-mod intern;
-mod io;
-mod modules;
-mod namespace;
-mod object;
-mod os;
-mod parse;
-mod prepare;
-mod repl;
-mod resource;
-mod run;
-mod run_progress;
-mod signature;
-mod sorting;
-mod types;
-mod value;
-
-#[cfg(feature = "ref-count-return")]
-pub use crate::run::RefCountOutput;
-pub use crate::{
-    exception_private::ExcType,
-    exception_public::{CodeLoc, MontyException, StackFrame},
-    io::{PrintWriter, PrintWriterCallback},
-    object::{DictPairs, InvalidInputError, MontyObject},
-    os::{OsFunction, dir_stat, file_stat, stat_result, symlink_stat},
-    repl::{
-        MontyRepl, ReplContinuationMode, ReplFunctionCall, ReplNameLookup, ReplOsCall, ReplProgress,
-        ReplResolveFutures, ReplStartError, detect_repl_continuation_mode,
-    },
-    resource::{
-        DEFAULT_MAX_RECURSION_DEPTH, LimitedTracker, NoLimitTracker, ResourceError, ResourceLimits, ResourceTracker,
-    },
-    run::MontyRun,
-    run_progress::{
-        ExtFunctionResult, FunctionCall, NameLookup, NameLookupResult, OsCall, ResolveFutures, RunProgress,
-    },
-};

package/ref-monty/crates/monty/src/modules/asyncio.rs

@@ -1,144 +0,0 @@
-//! Implementation of the `asyncio` module.
-//!
-//! Provides a minimal implementation of Python's `asyncio` module with:
-//! - `run(coro)`: Runs a coroutine to completion, equivalent to `await coro`
-//! - `gather(*awaitables)`: Collects coroutines for concurrent execution
-//!
-//! Other asyncio functions (`create_task`, `sleep`, `wait`, etc.) are not implemented.
-//! The host acts as the event loop - Monty yields control when tasks are blocked.
-
-use crate::{
-    args::ArgValues,
-    asyncio::{GatherFuture, GatherItem},
-    bytecode::{CallResult, VM},
-    defer_drop_mut,
-    exception_private::{ExcType, RunResult},
-    heap::{Heap, HeapData, HeapId},
-    intern::StaticStrings,
-    modules::ModuleFunctions,
-    resource::{ResourceError, ResourceTracker},
-    types::Module,
-    value::Value,
-};
-
-/// Async Functions.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, serde::Serialize, serde::Deserialize)]
-#[strum(serialize_all = "lowercase")]
-pub(crate) enum AsyncioFunctions {
-    Gather,
-    Run,
-}
-
-/// Creates the `asyncio` module and allocates it on the heap.
-///
-/// The module contains only the `gather` function. Other asyncio functions
-/// are not implemented as they would require additional VM/scheduler features.
-///
-/// # Returns
-/// A HeapId pointing to the newly allocated module.
-///
-/// # Panics
-/// Panics if the required strings have not been pre-interned during prepare phase.
-pub fn create_module(vm: &mut VM<'_, '_, impl ResourceTracker>) -> Result<HeapId, ResourceError> {
-    let mut module = Module::new(StaticStrings::Asyncio);
-
-    module.set_attr(
-        StaticStrings::Gather,
-        Value::ModuleFunction(ModuleFunctions::Asyncio(AsyncioFunctions::Gather)),
-        vm,
-    );
-    module.set_attr(
-        StaticStrings::Run,
-        Value::ModuleFunction(ModuleFunctions::Asyncio(AsyncioFunctions::Run)),
-        vm,
-    );
-
-    vm.heap.allocate(HeapData::Module(module))
-}
-pub(super) fn call(
-    heap: &mut Heap<impl ResourceTracker>,
-    functions: AsyncioFunctions,
-    args: ArgValues,
-) -> RunResult<CallResult> {
-    match functions {
-        AsyncioFunctions::Gather => gather(heap, args).map(CallResult::Value),
-        AsyncioFunctions::Run => run(heap, args),
-    }
-}
-
-/// Implementation of `asyncio.run(coro)`.
-///
-/// Runs a single coroutine to completion, equivalent to `await coro` at the top level.
-/// Accepts exactly one positional argument (the coroutine) and no keyword arguments.
-///
-/// Returns `CallResult::AwaitValue` so the VM executes `exec_get_awaitable` on
-/// the value, which handles validation that it's actually a coroutine/awaitable.
-fn run(heap: &mut Heap<impl ResourceTracker>, args: ArgValues) -> RunResult<CallResult> {
-    let coroutine = args.get_one_arg("asyncio.run", heap)?;
-    Ok(CallResult::AwaitValue(coroutine))
-}
-
-/// Implementation of `asyncio.gather(*awaitables)`.
-///
-/// Collects coroutines and external futures for concurrent execution. Does NOT
-/// spawn tasks immediately - just validates and stores the references. Tasks are
-/// spawned when the returned `GatherFuture` is awaited (in the `Await` opcode handler).
-///
-/// # Behavior when awaited
-///
-/// 1. Each coroutine is spawned as a separate Task
-/// 2. External futures are tracked for resolution by the host
-/// 3. The current task blocks until all items complete
-/// 4. Results are collected in order and returned as a list
-/// 5. On any task failure, sibling tasks are cancelled and the exception propagates
-///
-/// # Arguments
-/// * `heap` - The heap for allocating the GatherFuture
-/// * `args` - Variadic awaitable arguments (coroutines or external futures)
-///
-/// # Errors
-/// Returns `TypeError` if any argument is not awaitable.
-pub(crate) fn gather(heap: &mut Heap<impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let (pos_args, kwargs) = args.into_parts();
-    defer_drop_mut!(pos_args, heap);
-
-    // TODO: support keyword arguments (e.g. return_exceptions)
-    kwargs.not_supported_yet("gather", heap)?;
-
-    // Validate all positional args are awaitable and collect them
-    let mut items = Vec::new();
-    let mut coroutine_ids_to_cleanup: Vec<HeapId> = Vec::new();
-
-    #[cfg_attr(not(feature = "ref-count-panic"), expect(unused_mut))]
-    for mut arg in pos_args {
-        match &arg {
-            Value::Ref(id) if heap.get(*id).is_coroutine() => {
-                coroutine_ids_to_cleanup.push(*id);
-                items.push(GatherItem::Coroutine(*id));
-                // Transfer ownership to GatherFuture - mark Value as consumed without dec_ref
-                #[cfg(feature = "ref-count-panic")]
-                arg.dec_ref_forget();
-            }
-            Value::ExternalFuture(call_id) => {
-                items.push(GatherItem::ExternalFuture(*call_id));
-                // ExternalFuture is Copy, no refcount to manage
-            }
-            _ => {
-                // Not awaitable - clean up and error
-                arg.drop_with_heap(heap);
-                // Drop already-collected coroutine refs
-                for cid in coroutine_ids_to_cleanup {
-                    heap.dec_ref(cid);
-                }
-                return Err(ExcType::type_error(
-                    "An asyncio.Future, a coroutine or an awaitable is required",
-                ));
-            }
-        }
-    }
-
-    // Create GatherFuture on heap
-    let gather_future = GatherFuture::new(items);
-    let id = heap.allocate(HeapData::GatherFuture(gather_future))?;
-    Ok(Value::Ref(id))
-}