Standard Library

Monty includes a small, focused subset of the Python standard library optimized for agent code execution. This page documents all supported modules and their features.

Available Modules

Monty currently supports these standard library modules:

sys - System-specific parameters and functions
os - Operating system interface (sandboxed)
typing - Type hints and annotations
asyncio - Asynchronous programming support
re - Regular expression operations
pathlib - Object-oriented filesystem paths

More modules are planned: datetime, dataclasses, and json are coming soon.

sys Module

Provides system-specific parameters and functions.

Attributes

sys.version

Python version string identifying Monty.

import sys

print(sys.version)
# Output: "3.14.0 (Monty)"

sys.version_info

Named tuple containing version information.

import sys

print(sys.version_info)
# Output: sys.version_info(major=3, minor=14, micro=0, releaselevel='final', serial=0)

if sys.version_info.major >= 3:
    print('Python 3+')

sys.platform

Platform identifier (always "monty" for Monty).

import sys

print(sys.platform)
# Output: "monty"

sys.stdout / sys.stderr

Markers for standard output and error streams.

import sys

# These are markers, not actual file objects
print('Hello', file=sys.stdout)
print('Error', file=sys.stderr)

These are marker objects only and don’t provide full file I/O functionality.

os Module

Provides operating system functionality in a sandboxed environment.

All filesystem operations in Monty are sandboxed and must be explicitly enabled by the host. Direct filesystem access is blocked for security.

Path Operations

import os

# Path manipulation (safe, no filesystem access)
path = os.path.join('data', 'files', 'output.txt')
basename = os.path.basename(path)
dirname = os.path.dirname(path)

The os module in Monty focuses on path operations. File I/O operations like os.open(), os.read(), and os.write() are controlled by the host environment.

typing Module

Full support for Python’s type hint system.

Available Types

Generic Types

Standard generic types for annotations.

from typing import List, Dict, Set, Tuple, Optional, Union

def process(items: List[str]) -> Dict[str, int]:
    return {item: len(item) for item in items}

def find(key: str) -> Optional[str]:
    return data.get(key)  # Returns str or None

def parse(value: Union[int, str]) -> int:
    return int(value)

Type Aliases

Create type aliases for complex types.

from typing import List, Dict, Any

Messages = List[Dict[str, Any]]
Config = Dict[str, Union[str, int, bool]]

def agent(messages: Messages) -> str:
    return process(messages)

Callable Types

Type hints for callable objects.

from typing import Callable

def apply(func: Callable[[int], str], value: int) -> str:
    return func(value)

result = apply(str, 42)  # Returns "42"

Advanced Types

Literal, TypeVar, Protocol, and more.

from typing import Literal, TypeVar, Protocol

Mode = Literal['read', 'write', 'append']

T = TypeVar('T')

def first(items: List[T]) -> T:
    return items[0]

Type Checking

Monty includes ty for runtime type checking:

from typing import List

def process(items: List[str]) -> int:
    return len(items)

# Type checking happens automatically when enabled
# Catches type errors before execution

asyncio Module

Asynchronous programming support for agent workflows.

Functions

asyncio.run()

Run a coroutine to completion.

import asyncio

async def main():
    result = await fetch_data()
    return process(result)

# Run the async function
output = asyncio.run(main())

asyncio.gather()

Run multiple coroutines concurrently.

import asyncio

async def agent(prompt: str):
    # Fetch multiple resources concurrently
    results = await asyncio.gather(
        fetch_user_data(user_id),
        fetch_preferences(user_id),
        fetch_history(user_id)
    )
    user, prefs, history = results
    return combine(user, prefs, history)

The host acts as the event loop. Monty yields control when tasks are blocked, allowing efficient concurrent execution.

What’s NOT Included

These asyncio features are not implemented as they require additional scheduler features:

asyncio.create_task()
asyncio.sleep()
asyncio.wait()
asyncio.wait_for()
Event loops and task scheduling APIs

The host environment acts as the event loop. Task scheduling is managed externally, not by Monty.

re Module

Regular expression matching operations powered by fancy-regex.

Pattern Matching

Basic Matching

Find patterns in strings.

import re

# Search for first match
match = re.search(r'\d+', 'Order 12345 confirmed')
if match:
    print(match.group())  # "12345"

# Match from start
if re.match(r'[A-Z]', 'Hello'):
    print('Starts with uppercase')

# Match entire string
if re.fullmatch(r'\d{5}', '12345'):
    print('Valid 5-digit code')

Finding All Matches

Extract all occurrences of a pattern.

import re

text = 'Prices: $10, $25, $99'
prices = re.findall(r'\$(\d+)', text)
print(prices)  # ['10', '25', '99']

# Iterate over matches
for match in re.finditer(r'\d+', 'a1b2c3'):
    print(match.group())  # Prints: 1, 2, 3

Substitution

Replace pattern matches.

import re

# Replace all occurrences
text = 'Hello World'
result = re.sub(r'World', 'Python', text)
print(result)  # "Hello Python"

# Limit replacements
result = re.sub(r'a', 'x', 'banana', count=2)
print(result)  # "bxnxna"

Splitting

Split strings by pattern.

import re

parts = re.split(r'[,;]\s*', 'a, b; c,d')
print(parts)  # ['a', 'b', 'c', 'd']

# Limit splits
parts = re.split(r'\s+', 'a b c d', maxsplit=2)
print(parts)  # ['a', 'b', 'c d']

Compiled Patterns

Compile patterns for reuse.

import re

# Compile once, use many times
pattern = re.compile(r'\w+@\w+\.\w+')

emails = [
    'contact@example.com',
    'invalid-email',
    'admin@site.org'
]

for email in emails:
    if pattern.match(email):
        print(f'{email} is valid')

Flags

Supported regex flags:

import re

# Case-insensitive matching
re.search(r'hello', 'HELLO', re.IGNORECASE)  # or re.I

# Multiline mode (^ and $ match line boundaries)
re.search(r'^start', text, re.MULTILINE)  # or re.M

# Dot matches newlines
re.search(r'a.b', 'a\nb', re.DOTALL)  # or re.S

# ASCII-only mode for \w, \d, \s
re.search(r'\w+', text, re.ASCII)  # or re.A

pathlib Module

Object-oriented filesystem path manipulation.

from pathlib import Path

# Create paths
path = Path('data') / 'files' / 'output.txt'

# Path properties
print(path.name)       # "output.txt"
print(path.stem)       # "output"
print(path.suffix)     # ".txt"
print(path.parent)     # Path('data/files')

# Path operations
path = path.with_suffix('.json')
path = path.with_name('input.txt')

Like os, pathlib operations that access the filesystem are sandboxed. Path manipulation is safe, but file operations are controlled by the host.

Coming Soon

These modules are planned for future releases:

datetime - Date and time handling
dataclasses - Data class decorators
json - JSON encoding and decoding

Third-party libraries are not supported and are not a goal for Monty. The interpreter is designed specifically for agent-written code using only the stdlib.

Get Started

Core Concepts

Guides

Language Support

Standard Library

Available Modules

sys Module

Attributes

os Module

Path Operations

typing Module

Available Types

Type Checking

asyncio Module

Functions

What’s NOT Included

re Module

Pattern Matching

Flags

pathlib Module

Coming Soon

Next Steps

Python Subset

Limitations

Get Started

Core Concepts

Guides

Language Support

Documentation Index

​Available Modules

​sys Module

​Attributes

​os Module

​Path Operations

​typing Module

​Available Types

​Type Checking

​asyncio Module

​Functions

​What’s NOT Included

​re Module

​Pattern Matching

​Flags

​pathlib Module

​Coming Soon

​Next Steps

Python Subset

Limitations

Available Modules

sys Module

Attributes

os Module

Path Operations

typing Module

Available Types

Type Checking

asyncio Module

Functions

What’s NOT Included

re Module

Pattern Matching

Flags

pathlib Module

Coming Soon

Next Steps