Add pandas and numpy support for LLM-generated Python

Built-in pandas DataFrame/Series and numpy ndarray support, enabling
LLMs to write realistic data-analysis scripts combining multiple
operations in a single tool call.

NumPy: array creation, math functions, arithmetic/broadcasting,
comparisons, reshaping, and aggregation methods.

Pandas: DataFrame/Series creation, indexing, filtering, sorting,
groupby with aggregation, merge/concat/melt/pivot_table, apply,
iterrows/itertuples, string/datetime accessors, and null handling.

All types are heap-allocated with proper reference counting.
Pure Rust implementation — no real pandas/numpy dependency.

Author: trevorprater

README.md

@@ -37,11 +37,12 @@ What Monty **can** do:
 - Collect stdout and stderr and return it to the caller
 - Run async or sync code on the host via async or sync code on the host
 - Use a small subset of the standard library: `sys`, `os`, `typing`, `asyncio`, `re`, `datetime` (soon), `dataclasses` (soon), `json` (soon)
+- Use built-in `pandas` and `numpy` emulation — the subset of DataFrame, Series, and ndarray operations that LLMs commonly write (groupby, merge, pivot, filtering, aggregation, etc.) works out of the box, enabling LLMs to write data manipulation scripts as a single tool call
 
 What Monty **cannot** do:
 
 - Use the rest of the standard library
-- Use third party libraries (like Pydantic), support for external python library is not a goal
+- Use arbitrary third party libraries (like Pydantic) — however, `pandas` and `numpy` are built-in
 - define classes (support should come soon)
 - use match statements (again, support should come soon)
 
@@ -356,7 +357,7 @@ Details on each row below:
 
 ### Monty
 
-- **Language completeness**: No classes (yet), limited stdlib, no third-party libraries
+- **Language completeness**: No classes (yet), limited stdlib, but includes built-in pandas/numpy emulation for data manipulation
 - **Security**: Explicitly controlled filesystem, network, and env access, strict limits on execution time and memory usage
 - **Start latency**: Starts in microseconds
 - **Setup complexity**: just `pip install pydantic-monty` or `npm install @pydantic/monty`, ~4.5MB download

crates/monty/src/args.rs

@@ -4,7 +4,7 @@ use crate::{
     MontyObject, ResourceTracker, defer_drop, defer_drop_mut,
     exception_private::{ExcType, RunError, RunResult, SimpleException},
     expressions::{ExprLoc, Identifier},
-    heap::{ContainsHeap, DropWithHeap, Heap, HeapGuard},
+    heap::{ContainsHeap, DropWithHeap, Heap, HeapData, HeapGuard},
     intern::{Interns, StringId},
     parse::ParseError,
     types::{Dict, dict::DictIntoIter},
@@ -285,6 +285,22 @@ impl ArgValues {
         }
     }
 
+    /// Returns true if the first positional argument is callable (function/closure).
+    ///
+    /// Used to distinguish `map(dict)` from `map(callable)` without consuming args.
+    pub fn first_is_callable(&self, heap: &Heap<impl ResourceTracker>) -> bool {
+        let first = match self {
+            Self::One(v) | Self::Two(v, _) => Some(v),
+            Self::ArgsKargs { args, .. } => args.first(),
+            Self::Empty | Self::Kwargs(_) => None,
+        };
+        match first {
+            Some(Value::DefFunction(_)) => true,
+            Some(Value::Ref(id)) => matches!(heap.get(*id), HeapData::Closure(_)),
+            _ => false,
+        }
+    }
+
     /// Returns the number of positional arguments.
     ///
     /// For `Kwargs` returns 0, for `ArgsKargs` returns only the positional args count.