superacli 1.1.6 → 1.1.8

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

@@ -1,208 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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)