superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty-python/tests/test_print.py

@@ -0,0 +1,208 @@
+from typing import Callable, Literal
+
+import pytest
+from inline_snapshot import snapshot
+
+import pydantic_monty
+
+PrintCallback = Callable[[Literal['stdout'], str], None]
+
+
+def make_print_collector() -> tuple[list[str], PrintCallback]:
+    """Create a print callback that collects output into a list."""
+    output: list[str] = []
+
+    def callback(stream: Literal['stdout'], text: str) -> None:
+        assert stream == 'stdout'
+        output.append(text)
+
+    return output, callback
+
+
+def test_print_basic() -> None:
+    m = pydantic_monty.Monty('print("hello")')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('hello\n')
+
+
+def test_print_multiple() -> None:
+    code = """
+print("line 1")
+print("line 2")
+"""
+    m = pydantic_monty.Monty(code)
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('line 1\nline 2\n')
+
+
+def test_print_with_values() -> None:
+    m = pydantic_monty.Monty('print(1, 2, 3)')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('1 2 3\n')
+
+
+def test_print_with_sep() -> None:
+    m = pydantic_monty.Monty('print(1, 2, 3, sep="-")')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('1-2-3\n')
+
+
+def test_print_with_end() -> None:
+    m = pydantic_monty.Monty('print("hello", end="!")')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('hello!')
+
+
+def test_print_returns_none() -> None:
+    m = pydantic_monty.Monty('print("test")')
+    _, callback = make_print_collector()
+    result = m.run(print_callback=callback)
+    assert result is None
+
+
+def test_print_empty() -> None:
+    m = pydantic_monty.Monty('print()')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('\n')
+
+
+def test_print_with_limits() -> None:
+    """Verify print_callback works together with resource limits."""
+    m = pydantic_monty.Monty('print("with limits")')
+    output, callback = make_print_collector()
+    limits = pydantic_monty.ResourceLimits(max_duration_secs=5.0)
+    m.run(print_callback=callback, limits=limits)
+    assert ''.join(output) == snapshot('with limits\n')
+
+
+def test_print_with_inputs() -> None:
+    """Verify print_callback works together with inputs."""
+    m = pydantic_monty.Monty('print(x)', inputs=['x'])
+    output, callback = make_print_collector()
+    m.run(inputs={'x': 42}, print_callback=callback)
+    assert ''.join(output) == snapshot('42\n')
+
+
+def test_print_in_loop() -> None:
+    code = """
+for i in range(3):
+    print(i)
+"""
+    m = pydantic_monty.Monty(code)
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('0\n1\n2\n')
+
+
+def test_print_mixed_types() -> None:
+    m = pydantic_monty.Monty('print(1, "hello", True, None)')
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('1 hello True None\n')
+
+
+def make_error_callback(error: Exception) -> PrintCallback:
+    """Create a print callback that raises an exception."""
+
+    def callback(stream: Literal['stdout'], text: str) -> None:
+        raise error
+
+    return callback
+
+
+def test_print_callback_raises_value_error() -> None:
+    """Test that ValueError raised in callback propagates correctly."""
+    m = pydantic_monty.Monty('print("hello")')
+    callback = make_error_callback(ValueError('callback error'))
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(print_callback=callback)
+    inner = exc_info.value.exception()
+    assert isinstance(inner, ValueError)
+    assert inner.args[0] == snapshot('callback error')
+
+
+def test_print_callback_raises_type_error() -> None:
+    """Test that TypeError raised in callback propagates correctly."""
+    m = pydantic_monty.Monty('print("hello")')
+    callback = make_error_callback(TypeError('wrong type'))
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(print_callback=callback)
+    inner = exc_info.value.exception()
+    assert isinstance(inner, TypeError)
+    assert inner.args[0] == snapshot('wrong type')
+
+
+def test_print_callback_raises_in_function() -> None:
+    """Test exception from callback when print is called inside a function."""
+    code = """
+def greet(name):
+    print(f"Hello, {name}!")
+
+greet("World")
+"""
+    m = pydantic_monty.Monty(code)
+    callback = make_error_callback(RuntimeError('io error'))
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(print_callback=callback)
+    inner = exc_info.value.exception()
+    assert isinstance(inner, RuntimeError)
+    assert inner.args[0] == snapshot('io error')
+
+
+def test_print_callback_raises_in_nested_function() -> None:
+    """Test exception from callback when print is called in nested functions."""
+    code = """
+def outer():
+    def inner():
+        print("from inner")
+    inner()
+
+outer()
+"""
+    m = pydantic_monty.Monty(code)
+    callback = make_error_callback(ValueError('nested error'))
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(print_callback=callback)
+    inner = exc_info.value.exception()
+    assert isinstance(inner, ValueError)
+    assert inner.args[0] == snapshot('nested error')
+
+
+def test_print_callback_raises_in_loop() -> None:
+    """Test exception from callback when print is called in a loop."""
+    code = """
+for i in range(5):
+    print(i)
+"""
+    m = pydantic_monty.Monty(code)
+    call_count = 0
+
+    def callback(stream: Literal['stdout'], text: str) -> None:
+        nonlocal call_count
+        call_count += 1
+        if call_count >= 3:
+            raise ValueError('stopped at 3')
+
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(print_callback=callback)
+    inner = exc_info.value.exception()
+    assert isinstance(inner, ValueError)
+    assert inner.args[0] == snapshot('stopped at 3')
+    assert call_count == snapshot(3)
+
+
+def test_map_print() -> None:
+    """Test that print can be used inside map."""
+    code = """
+list(map(print, [1, 2, 3]))
+"""
+    m = pydantic_monty.Monty(code)
+    output, callback = make_print_collector()
+    m.run(print_callback=callback)
+    assert ''.join(output) == snapshot('1\n2\n3\n')

package/ref-monty/crates/monty-python/tests/test_re.py

@@ -0,0 +1,170 @@
+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.load_snapshot(data)
+    assert isinstance(progress2, pydantic_monty.FunctionSnapshot)
+
+    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

package/ref-monty/crates/monty-python/tests/test_readme_examples.py

@@ -0,0 +1,20 @@
+import pytest
+from pytest_examples import CodeExample, EvalExample, find_examples
+
+paths = (
+    'crates/monty-python/README.md',
+    'README.md',
+)
+
+
+@pytest.mark.parametrize('example', find_examples(*paths), ids=str)
+def test_readme_examples(example: CodeExample, eval_example: EvalExample):
+    eval_example.set_config(target_version='py310', ruff_ignore=['FA102'])
+    eval_example.lint(example)
+    opt_test = example.prefix_settings().get('test', '')
+    if opt_test.startswith('skip'):
+        pytest.skip(opt_test[4:].lstrip(' -') or 'running code skipped')
+    if eval_example.update_examples:
+        eval_example.run_print_update(example)
+    else:
+        eval_example.run_print_check(example)