re module implementation (#157)

Co-authored-by: Embers-of-the-Fire <Embers-of-the-Fire>
Co-authored-by: Samuel Colvin <s@muelcolvin.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: 3 people

Cargo.lock

@@ -36,10 +36,11 @@ What Monty **can** do:
 - Control resource usage - Monty can track memory usage, allocations, stack depth, and execution time and cancel execution if it exceeds preset limits
 - 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)
 
 What Monty **cannot** do:
 
-- Use the standard library (except a few select modules: `sys`, `typing`, `asyncio`, `dataclasses` (soon), `json` (soon))
+- Use the rest of the standard library
 - Use third party libraries (like Pydantic), support for external python library is not a goal
 - define classes (support should come soon)
 - use match statements (again, support should come soon)

README.md

@@ -19,6 +19,7 @@ use pyo3::{
     PyClassInitializer, PyTypeCheck,
     exceptions::{self},
     prelude::*,
+    sync::PyOnceLock,
     types::{PyDict, PyList, PyString},
 };
 
@@ -408,6 +409,15 @@ pub fn exc_monty_to_py(py: Python<'_>, exc: MontyException) -> PyErr {
         ExcType::FileExistsError => exceptions::PyFileExistsError::new_err(msg),
         ExcType::IsADirectoryError => exceptions::PyIsADirectoryError::new_err(msg),
         ExcType::NotADirectoryError => exceptions::PyNotADirectoryError::new_err(msg),
+        ExcType::RePatternError => {
+            if let Ok(re_pattern_error) = get_re_pattern_error(py)
+                && let Ok(exc_instance) = re_pattern_error.call1((PyString::new(py, &msg),))
+            {
+                PyErr::from_value(exc_instance)
+            } else {
+                exceptions::PyRuntimeError::new_err(msg)
+            }
+        }
     }
 }
 
@@ -535,3 +545,13 @@ fn is_frozen_instance_error(exc: &Bound<'_, exceptions::PyBaseException>) -> boo
         false
     }
 }
+
+fn get_re_pattern_error(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {
+    static RE_PATTERN_ERROR: PyOnceLock<Py<PyAny>> = PyOnceLock::new();
+
+    if cfg!(Py_3_13) {
+        RE_PATTERN_ERROR.import(py, "re", "PatternError")
+    } else {
+        RE_PATTERN_ERROR.import(py, "re", "error")
+    }
+}

crates/monty-python/src/exceptions.rs

@@ -0,0 +1,169 @@
+import re
+import sys
+
+import pytest
+from inline_snapshot import snapshot
+
+import pydantic_monty
+
+
+def test_re_module():
+    m = pydantic_monty.Monty('import re')
+    output = m.run()
+    assert output is None
+
+
+def test_re_compile():
+    code = """
+import re
+pattern = re.compile(r'\\d+')
+matches = pattern.findall('There are 24 hours in a day and 365 days in a year.')
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert output is None
+
+
+supported_flags = [
+    (['re.I', 're.IGNORECASE'], re.IGNORECASE),
+    (['re.M', 're.MULTILINE'], re.MULTILINE),
+    (['re.S', 're.DOTALL'], re.DOTALL),
+]
+if sys.version_info >= (3, 11):
+    supported_flags.append((['re.NOFLAG'], re.NOFLAG))
+
+
+@pytest.mark.parametrize(
+    'flags,target',
+    supported_flags,
+    ids=str,
+)
+def test_re_constant(flags: list[str], target: int):
+    code = f'import re; ({",".join(flags)},)'
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert all(map(lambda orig: orig == target, output))
+
+
+def test_re_compile_repr():
+    code = r"""
+import re
+pattern = re.compile(r'\d+', re.IGNORECASE | re.DOTALL)
+pattern
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert output == r"re.compile('\\d+', re.IGNORECASE|re.DOTALL)"
+
+
+def test_re_match_repr():
+    code = """
+import re
+pattern = re.compile(r'\\d+')
+pattern.match('123abc')
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert output == "<re.Match object; span=(0, 3), match='123'>"
+
+
+def test_re_match_groups():
+    code = """
+import re
+pattern = re.compile(r'(\\d+)-(\\w+)')
+match = pattern.match('123-abc')
+match.groups()
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert output == ('123', 'abc')
+
+
+def test_re_substitution():
+    code = """
+import re
+pattern = re.compile(r'\\s+')
+result = pattern.sub('-', 'This is a test.')
+result
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    assert output == 'This-is-a-test.'
+
+
+def test_re_error_handling():
+    code = """
+import re
+try:
+    pattern = re.compile(r'[')
+except Exception as e:
+    error_message = str(e)
+error_message
+"""
+    m = pydantic_monty.Monty(code)
+    output = m.run()
+    error = 'Parsing error at position 1: Invalid character class'
+    assert error in output
+
+
+def test_re_resume():
+    code = """
+import re
+pattern = re.compile(func())
+matches = pattern.findall('Sample 123 text 456')
+dump(matches)
+"""
+    m = pydantic_monty.Monty(code)
+    progress = m.start()
+    assert isinstance(progress, pydantic_monty.FunctionSnapshot)
+
+    assert progress.function_name == snapshot('func')
+    assert progress.args == snapshot(())
+    assert progress.kwargs == snapshot({})
+
+    progress2 = progress.resume(return_value='\\d+')
+    assert isinstance(progress2, pydantic_monty.FunctionSnapshot)
+
+    result = progress2.resume(return_value=['123', '456'])
+    assert isinstance(result, pydantic_monty.MontyComplete)
+    assert result.output == snapshot(['123', '456'])
+
+
+def test_re_persistence():
+    code = """
+import re
+pattern = re.compile(r'\\w+')
+dump()
+matches = pattern.findall('Test 123!')
+matches
+"""
+    m = pydantic_monty.Monty(code)
+    progress = m.start()
+    assert isinstance(progress, pydantic_monty.FunctionSnapshot)
+
+    data = progress.dump()
+
+    progress2 = pydantic_monty.FunctionSnapshot.load(data)
+
+    result = progress2.resume(return_value=None)
+    assert isinstance(result, pydantic_monty.MontyComplete)
+    assert result.output == snapshot(['Test', '123'])
+
+
+def test_re_error_upcast():
+    code = """
+import re
+re.compile(r'[')
+"""
+    m = pydantic_monty.Monty(code)
+    try:
+        m.run()
+        assert False, 'Expected an exception to be raised'
+    except pydantic_monty.MontyRuntimeError as e:
+        error_message = str(e)
+        assert True, 'Expected an exception to be raised'
+        if sys.version_info >= (3, 13):
+            assert type(e.exception()) is re.PatternError
+        else:
+            assert type(e.exception()) is re.error
+        assert 'Parsing error at position 1: Invalid character class' in error_message

crates/monty-python/tests/test_re.py

@@ -1,9 +1,10 @@
 import asyncio
 import os
+import re
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import assert_type
+from typing import Any, assert_type
 
 # === Type checking helper functions ===
 
@@ -428,3 +429,47 @@ class Point:
 
 x2 = os.environ.get('foobar')
 assert_type(x2, str | None)
+
+
+# === re module ===
+
+# re.search returns Match or None
+s1 = re.search(r'\d+', 'abc 42')
+assert_type(s1, re.Match[str] | None)
+
+# re.match returns Match or None
+s2 = re.match(r'\w+', 'hello')
+assert_type(s2, re.Match[str] | None)
+
+# re.fullmatch returns Match or None
+s3 = re.fullmatch(r'\w+', 'hello')
+assert_type(s3, re.Match[str] | None)
+
+# re.compile returns Pattern
+p_re = re.compile(r'\d+')
+assert_type(p_re, re.Pattern[str])
+
+# re.findall returns list of Any
+fa = re.findall(r'\d+', 'a1 b2 c3')
+assert_type(fa, list[Any])
+
+# re.sub returns str
+s4 = re.sub(r'\d+', 'X', 'a1 b2')
+assert_type(s4, str)
+
+# Pattern.search returns Match or None
+p_re2 = re.compile(r'(\w+)')
+s5 = p_re2.search('hello world')
+assert_type(s5, re.Match[str] | None)
+
+# Pattern.match returns Match or None
+s6 = p_re2.match('hello world')
+assert_type(s6, re.Match[str] | None)
+
+# Pattern.sub returns str
+s7 = p_re2.sub('X', 'hello world')
+assert_type(s7, str)
+
+# Pattern.findall returns list of Any
+fa2 = p_re2.findall('hello world')
+assert_type(fa2, list[Any])

crates/monty-type-checking/tests/good_types.py

@@ -106,6 +106,8 @@
     'dataclasses.pyi',
     # used by dataclasses
     'enum.pyi',
+    # the re std lib module is not mostly implemented
+    're.pyi',
     # ==============================
     # all all collections dir
     'collections/__init__.pyi',
@@ -120,9 +122,10 @@
 ]
 # content for typeshed's `VERSIONS` file
 VERSIONS = """\
-# absolutely minimal VERSIONS file exposing only the modules required
-# all these modules are required to get type checking working with ty
-# or for the stdlib modules we (partially) implement
+# DO NOT EDIT THIS FILE DIRECTLY
+# instead edit crates/monty-typeshed/update.py
+# this file should match the modules
+# which monty's minimimal typeshed includes
 
 _collections_abc: 3.3-
 _typeshed: 3.0-  # not present at runtime, only for type checking
@@ -133,6 +136,7 @@
 os: 3.0-
 pathlib: 3.4-
 pathlib.types: 3.14-
+re: 3.0-
 sys: 3.0-
 typing: 3.5-
 typing_extensions: 3.7-

crates/monty-typeshed/update.py

@@ -1,6 +1,7 @@
-# absolutely minimal VERSIONS file exposing only the modules required
-# all these modules are required to get type checking working with ty
-# or for the stdlib modules we (partially) implement
+# DO NOT EDIT THIS FILE DIRECTLY
+# instead edit crates/monty-typeshed/update.py
+# this file should match the modules
+# which monty's minimimal typeshed includes
 
 _collections_abc: 3.3-
 _typeshed: 3.0-  # not present at runtime, only for type checking
@@ -11,6 +12,7 @@ dataclasses: 3.7-
 os: 3.0-
 pathlib: 3.4-
 pathlib.types: 3.14-
+re: 3.0-
 sys: 3.0-
 typing: 3.5-
 typing_extensions: 3.7-