superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/test_cases/args__dict_get_no_args.py

@@ -0,0 +1,3 @@
+x = {}
+x.get()
+# Raise=TypeError('get expected at least 1 argument, got 0')

package/ref-monty/crates/monty/test_cases/args__dict_get_too_many.py

@@ -0,0 +1,3 @@
+x = {}
+x.get(1, 2, 3)
+# Raise=TypeError('get expected at most 2 arguments, got 3')

package/ref-monty/crates/monty/test_cases/args__dict_items_with_args.py

@@ -0,0 +1,3 @@
+x = {}
+x.items(1)
+# Raise=TypeError('dict.items() takes no arguments (1 given)')

package/ref-monty/crates/monty/test_cases/args__dict_keys_with_args.py

@@ -0,0 +1,3 @@
+x = {}
+x.keys(1)
+# Raise=TypeError('dict.keys() takes no arguments (1 given)')

package/ref-monty/crates/monty/test_cases/args__dict_pop_no_args.py

@@ -0,0 +1,3 @@
+x = {}
+x.pop()
+# Raise=TypeError('pop expected at least 1 argument, got 0')

package/ref-monty/crates/monty/test_cases/args__dict_pop_too_many.py

@@ -0,0 +1,3 @@
+x = {}
+x.pop(1, 2, 3)
+# Raise=TypeError('pop expected at most 2 arguments, got 3')

package/ref-monty/crates/monty/test_cases/args__dict_values_with_args.py

@@ -0,0 +1,3 @@
+x = {}
+x.values(1)
+# Raise=TypeError('dict.values() takes no arguments (1 given)')

package/ref-monty/crates/monty/test_cases/args__id_too_many.py

@@ -0,0 +1,2 @@
+id(1, 2)
+# Raise=TypeError('id() takes exactly one argument (2 given)')

package/ref-monty/crates/monty/test_cases/args__len_no_args.py

@@ -0,0 +1,2 @@
+len()
+# Raise=TypeError('len() takes exactly one argument (0 given)')

package/ref-monty/crates/monty/test_cases/args__len_too_many.py

@@ -0,0 +1,2 @@
+len(1, 2)
+# Raise=TypeError('len() takes exactly one argument (2 given)')

package/ref-monty/crates/monty/test_cases/args__len_type_error_int.py

@@ -0,0 +1,9 @@
+len(42)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "args__len_type_error_int.py", line 1, in <module>
+    len(42)
+    ~~~~~~~
+TypeError: object of type 'int' has no len()
+"""

package/ref-monty/crates/monty/test_cases/args__len_type_error_none.py

@@ -0,0 +1,9 @@
+len(None)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "args__len_type_error_none.py", line 1, in <module>
+    len(None)
+    ~~~~~~~~~
+TypeError: object of type 'NoneType' has no len()
+"""

package/ref-monty/crates/monty/test_cases/args__list_append_no_args.py

@@ -0,0 +1,3 @@
+x = []
+x.append()
+# Raise=TypeError('list.append() takes exactly one argument (0 given)')

package/ref-monty/crates/monty/test_cases/args__list_append_too_many.py

@@ -0,0 +1,3 @@
+x = []
+x.append(1, 2)
+# Raise=TypeError('list.append() takes exactly one argument (2 given)')

package/ref-monty/crates/monty/test_cases/args__list_insert_too_few.py

@@ -0,0 +1,3 @@
+x = []
+x.insert(1)
+# Raise=TypeError('insert expected 2 arguments, got 1')

package/ref-monty/crates/monty/test_cases/args__list_insert_too_many.py

@@ -0,0 +1,3 @@
+x = []
+x.insert(1, 2, 3)
+# Raise=TypeError('insert expected 2 arguments, got 3')

package/ref-monty/crates/monty/test_cases/args__repr_no_args.py

@@ -0,0 +1,2 @@
+repr()
+# Raise=TypeError('repr() takes exactly one argument (0 given)')

package/ref-monty/crates/monty/test_cases/arith__div_zero_float.py

@@ -0,0 +1,2 @@
+1.0 / 0.0
+# Raise=ZeroDivisionError('division by zero')

package/ref-monty/crates/monty/test_cases/arith__div_zero_int.py

@@ -0,0 +1,2 @@
+1 / 0
+# Raise=ZeroDivisionError('division by zero')

package/ref-monty/crates/monty/test_cases/arith__floordiv_zero_float.py

@@ -0,0 +1,2 @@
+1.0 // 0.0
+# Raise=ZeroDivisionError('division by zero')

package/ref-monty/crates/monty/test_cases/arith__floordiv_zero_int.py

@@ -0,0 +1,2 @@
+1 // 0
+# Raise=ZeroDivisionError('division by zero')

package/ref-monty/crates/monty/test_cases/arith__pow_zero_neg.py

@@ -0,0 +1,2 @@
+0**-1
+# Raise=ZeroDivisionError('zero to a negative power')

package/ref-monty/crates/monty/test_cases/arith__pow_zero_neg_builtin.py

@@ -0,0 +1,9 @@
+pow(0, -1)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "arith__pow_zero_neg_builtin.py", line 1, in <module>
+    pow(0, -1)
+    ~~~~~~~~~~
+ZeroDivisionError: zero to a negative power
+"""

package/ref-monty/crates/monty/test_cases/assert__expr_fail.py

@@ -0,0 +1,2 @@
+assert 1 == 2
+# Raise=AssertionError()

package/ref-monty/crates/monty/test_cases/assert__fail.py

@@ -0,0 +1,2 @@
+assert False
+# Raise=AssertionError()

package/ref-monty/crates/monty/test_cases/assert__fail_msg.py

@@ -0,0 +1,2 @@
+assert False, 'custom message'
+# Raise=AssertionError('custom message')

package/ref-monty/crates/monty/test_cases/assert__fn_fail.py

@@ -0,0 +1,3 @@
+# fmt: off
+assert(0)
+# Raise=AssertionError()

package/ref-monty/crates/monty/test_cases/assert__ops.py

@@ -0,0 +1,11 @@
+# Tests for assert statements that pass (failure cases are in separate files)
+# === Basic assert ===
+assert True, 'basic assert True'
+
+# === Assert with expression ===
+assert 1 == 1, 'assert equality expression'
+
+# === Assert with function call style (assert is statement, not function) ===
+# fmt: off
+assert(123)
+# fmt: on

package/ref-monty/crates/monty/test_cases/async__asyncio_run.py

@@ -0,0 +1,47 @@
+import asyncio
+
+
+# === Basic asyncio.run ===
+async def simple():
+    return 42
+
+
+result = asyncio.run(simple())
+assert result == 42, f'basic asyncio.run failed: {result}'
+
+
+# === With arguments ===
+async def add(a, b):
+    return a + b
+
+
+result = asyncio.run(add(10, 20))
+assert result == 30, f'asyncio.run with args failed: {result}'
+
+
+# === Nested awaits inside the coroutine ===
+async def inner():
+    return 'hello'
+
+
+async def outer():
+    val = await inner()
+    return val + ' world'
+
+
+result = asyncio.run(outer())
+assert result == 'hello world', f'nested awaits failed: {result}'
+
+
+# === asyncio.gather inside asyncio.run ===
+async def double(x):
+    return x * 2
+
+
+async def run_gather():
+    results = await asyncio.gather(double(1), double(2), double(3))
+    return results
+
+
+result = asyncio.run(run_gather())
+assert result == [2, 4, 6], f'gather inside run failed: {result}'

package/ref-monty/crates/monty/test_cases/async__basic.py

@@ -0,0 +1,10 @@
+# run-async
+# Basic async function that returns a value
+
+
+async def foo():
+    return 123
+
+
+result = await foo()  # pyright: ignore
+assert result == 123, 'async function should return awaited value'

package/ref-monty/crates/monty/test_cases/async__closure.py

@@ -0,0 +1,14 @@
+# run-async
+# Async function capturing variables from enclosing scope
+
+
+def make_adder(n):
+    async def adder(x):
+        return x + n
+
+    return adder
+
+
+add_five = make_adder(5)
+result = await add_five(10)  # pyright: ignore
+assert result == 15, 'async closure should capture variables'

package/ref-monty/crates/monty/test_cases/async__double_await_coroutine.py

@@ -0,0 +1,16 @@
+# run-async
+async def foo():
+    return 1
+
+
+coro = foo()
+await coro  # pyright: ignore
+await coro  # pyright: ignore
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "async__double_await_coroutine.py", line 8, in <module>
+    await coro  # pyright: ignore
+    ~~~~~~~~~~
+RuntimeError: cannot reuse already awaited coroutine
+"""

package/ref-monty/crates/monty/test_cases/async__exception.py

@@ -0,0 +1,10 @@
+# run-async
+# Test that exceptions in async functions propagate correctly
+
+
+async def raises_error():
+    raise ValueError('async error')
+
+
+await raises_error()  # pyright: ignore
+# Raise=ValueError('async error')

package/ref-monty/crates/monty/test_cases/async__ext_call.py

@@ -0,0 +1,73 @@
+# call-external
+# run-async
+# Test async external function calls (coroutines)
+
+# === Basic async external call ===
+result = await async_call(42)  # pyright: ignore
+assert result == 42, 'async_call should return awaited value'
+
+# === Async call with string ===
+s = await async_call('hello')  # pyright: ignore
+assert s == 'hello', 'async_call should work with strings'
+
+# === Async call with list ===
+lst = await async_call([1, 2, 3])  # pyright: ignore
+assert lst == [1, 2, 3], 'async_call should work with lists'
+
+# === Multiple async calls ===
+a = await async_call(10)  # pyright: ignore
+b = await async_call(20)  # pyright: ignore
+assert a + b == 30, 'multiple async calls should work'
+
+# === Gather multiple external async calls ===
+import asyncio
+
+results = await asyncio.gather(async_call(1), async_call(2), async_call(3))  # pyright: ignore
+assert results == [1, 2, 3], 'gather should collect external async results in order'
+
+# === Gather with mixed external calls ===
+results = await asyncio.gather(async_call('a'), async_call('b'))  # pyright: ignore
+assert results == ['a', 'b'], 'gather should work with string returns'
+
+
+# === Gather mixing coroutines and external futures ===
+async def add(a, b):
+    return a + b
+
+
+async def multiply(a, b):
+    return a * b
+
+
+# Mix: coroutine first, external future second
+results = await asyncio.gather(add(1, 2), async_call(10))  # pyright: ignore
+assert results == [3, 10], 'gather should work with coroutine then external future'
+
+# Mix: external future first, coroutine second
+results = await asyncio.gather(async_call(20), multiply(3, 4))  # pyright: ignore
+assert results == [20, 12], 'gather should work with external future then coroutine'
+
+# Mix: multiple of each interleaved
+results = await asyncio.gather(add(5, 5), async_call('x'), multiply(2, 3), async_call('y'))  # pyright: ignore
+assert results == [10, 'x', 6, 'y'], 'gather should handle interleaved coroutines and external futures'
+
+
+# === Coroutine with nested external awaits ===
+async def double_external(x):
+    val = await async_call(x)
+    return val * 2
+
+
+results = await asyncio.gather(double_external(5), async_call(100))  # pyright: ignore
+assert results == [10, 100], 'gather should work with coroutine that awaits external'
+
+
+# === Coroutine with multiple nested awaits ===
+async def triple_add(a, b, c):
+    x = await async_call(a)
+    y = await async_call(b)
+    return x + y + c
+
+
+results = await asyncio.gather(triple_add(1, 2, 3), async_call(50))  # pyright: ignore
+assert results == [6, 50], 'gather should work with coroutine with multiple external awaits'

package/ref-monty/crates/monty/test_cases/async__gather_all.py

@@ -0,0 +1,85 @@
+# run-async
+import asyncio
+
+
+# === Basic gather ===
+async def task1():
+    return 1
+
+
+async def task2():
+    return 2
+
+
+result = await asyncio.gather(task1(), task2())  # pyright: ignore
+assert result == [1, 2], 'gather should return results as a list'
+
+
+# === Result ordering ===
+# Results should be in argument order, not completion order
+async def slow():
+    return 'slow'
+
+
+async def fast():
+    return 'fast'
+
+
+result = await asyncio.gather(slow(), fast())  # pyright: ignore
+assert result == ['slow', 'fast'], 'gather should preserve argument order'
+
+# === Empty gather ===
+result = await asyncio.gather()  # pyright: ignore
+assert result == [], 'empty gather should return empty list'
+
+
+# === Single coroutine ===
+async def single():
+    return 42
+
+
+result = await asyncio.gather(single())  # pyright: ignore
+assert result == [42], 'gather with single coroutine should return list with one element'
+
+# === repr of gather function ===
+r = repr(asyncio.gather)
+assert r.startswith('<function gather at 0x'), f'repr should start with: {r}'
+
+# === TypeError for non-awaitable argument ===
+try:
+    await asyncio.gather(123)  # pyright: ignore
+    assert False, 'should have raised TypeError'
+except TypeError as e:
+    assert str(e) == 'An asyncio.Future, a coroutine or an awaitable is required'
+
+
+# === *args unpacking with gather ===
+async def a():
+    return 'a'
+
+
+async def b():
+    return 'b'
+
+
+async def c():
+    return 'c'
+
+
+# Unpack a list of coroutines
+coros = [a(), b(), c()]
+result = await asyncio.gather(*coros)  # pyright: ignore
+assert result == ['a', 'b', 'c'], f'gather with *args unpacking: {result}'
+
+# Unpack with mixed args
+result = await asyncio.gather(a(), *[b(), c()])  # pyright: ignore
+assert result == ['a', 'b', 'c'], f'gather with mixed args and *unpacking: {result}'
+
+# Unpack empty list
+result = await asyncio.gather(*[])  # pyright: ignore
+assert result == [], f'gather with empty *args: {result}'
+
+# Unpack tuple
+coro_tuple = (a(), b())
+result = await asyncio.gather(*coro_tuple)  # pyright: ignore
+assert result == ['a', 'b'], f'gather with *tuple unpacking: {result}'

package/ref-monty/crates/monty/test_cases/async__nested_await.py

@@ -0,0 +1,15 @@
+# run-async
+# Nested async function calls
+
+
+async def inner():
+    return 42
+
+
+async def outer():
+    value = await inner()
+    return value + 8
+
+
+result = await outer()  # pyright: ignore
+assert result == 50, 'nested async calls should work'

package/ref-monty/crates/monty/test_cases/async__nested_gather_ext.py

@@ -0,0 +1,37 @@
+# call-external
+# run-async
+# Test nested asyncio.gather where outer gather spawns tasks that each
+# do a sequential external await followed by an inner gather of external calls.
+import asyncio
+
+
+async def process_item(n):
+    base = await async_call(n * 10)
+    left = async_call(base + 1)
+    right = async_call(base + 2)
+    parts = await asyncio.gather(left, right)
+    return {'n': n, 'parts': parts}
+
+
+results = await asyncio.gather(  # pyright: ignore
+    process_item(1), process_item(2), process_item(3)
+)
+assert results == [
+    {'n': 1, 'parts': [11, 12]},
+    {'n': 2, 'parts': [21, 22]},
+    {'n': 3, 'parts': [31, 32]},
+], f'nested gather with external calls: {results}'
+
+
+# === Nested gather with generator unpacking ===
+async def fetch_pair(key):
+    val = await async_call(key)
+    return val
+
+
+async def fetch_all(keys):
+    return await asyncio.gather(*(fetch_pair(k) for k in keys))
+
+
+outer = await asyncio.gather(fetch_all([1, 2]), fetch_all([3, 4]))  # pyright: ignore
+assert outer == [[1, 2], [3, 4]], f'nested gather with generator unpacking: {outer}'

package/ref-monty/crates/monty/test_cases/async__not_awaitable.py

@@ -0,0 +1,10 @@
+# run-async
+await 123  # pyright: ignore
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "async__not_awaitable.py", line 2, in <module>
+    await 123  # pyright: ignore
+    ~~~~~~~~~
+TypeError: 'int' object can't be awaited
+"""

package/ref-monty/crates/monty/test_cases/async__not_imported.py

@@ -0,0 +1,14 @@
+# run-async
+async def foo():
+    return 1
+
+
+await asyncio.gather(foo(), foo())  # pyright: ignore
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "async__not_imported.py", line 6, in <module>
+    await asyncio.gather(foo(), foo())  # pyright: ignore
+          ~~~~~~~
+NameError: name 'asyncio' is not defined. Did you forget to import 'asyncio'?
+"""

package/ref-monty/crates/monty/test_cases/async__recursion_depth_isolation.py

@@ -0,0 +1,27 @@
+# call-external
+# run-async
+# Test that recursion depth is per-task, not global.
+#
+# With a recursion limit of 50, a gathered task that recurses 40 deep
+# should NOT eat into another task's budget. Without per-task depth
+# tracking, the second task inherits the first task's depth and hits
+# the limit prematurely.
+import asyncio
+
+
+async def recurse_then_call(n):
+    """Recurse n levels deep, then make an external call at the bottom."""
+    if n == 0:
+        return await async_call('done')
+    return await recurse_then_call(n - 1)
+
+
+# Each task recurses 40 deep independently.
+# With a global depth counter, the second task would start at depth 40
+# and blow the limit at depth 80 (well above the 50 limit).
+# With correct per-task tracking, each task sees its own depth of 40.
+results = await asyncio.gather(  # pyright: ignore
+    recurse_then_call(40),
+    recurse_then_call(40),
+)
+assert results == ['done', 'done'], f'both tasks should complete: {results}'

package/ref-monty/crates/monty/test_cases/async__return_types.py

@@ -0,0 +1,31 @@
+# run-async
+# Async functions returning different types
+
+
+async def return_int():
+    return 42
+
+
+async def return_str():
+    return 'hello'
+
+
+async def return_list():
+    return [1, 2, 3]
+
+
+async def return_none():
+    pass
+
+
+i = await return_int()  # pyright: ignore
+assert i == 42, 'should return int'
+
+s = await return_str()  # pyright: ignore
+assert s == 'hello', 'should return str'
+
+lst = await return_list()  # pyright: ignore
+assert lst == [1, 2, 3], 'should return list'
+
+n = await return_none()  # pyright: ignore
+assert n is None, 'should return None implicitly'

package/ref-monty/crates/monty/test_cases/async__sequential.py

@@ -0,0 +1,16 @@
+# run-async
+# Multiple sequential awaits
+
+
+async def get_value(x):
+    return x * 2
+
+
+a = await get_value(1)  # pyright: ignore
+b = await get_value(2)  # pyright: ignore
+c = await get_value(3)  # pyright: ignore
+
+assert a == 2, 'first await'
+assert b == 4, 'second await'
+assert c == 6, 'third await'
+assert a + b + c == 12, 'sum of sequential awaits'

package/ref-monty/crates/monty/test_cases/async__traceback.py

@@ -0,0 +1,19 @@
+# run-async
+# Test that exceptions in async functions produce correct tracebacks
+
+
+async def raises_error():
+    raise ValueError('async error')
+
+
+await raises_error()  # pyright: ignore
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "async__traceback.py", line 9, in <module>
+    await raises_error()  # pyright: ignore
+    ~~~~~~~~~~~~~~~~~~~~
+  File "async__traceback.py", line 6, in raises_error
+    raise ValueError('async error')
+ValueError: async error
+"""

package/ref-monty/crates/monty/test_cases/async__with_args.py

@@ -0,0 +1,14 @@
+# run-async
+# Async function with arguments
+
+
+async def add(a, b):
+    return a + b
+
+
+result = await add(10, 20)  # pyright: ignore
+assert result == 30, 'async function should handle arguments'
+
+# With keyword arguments
+result2 = await add(a=5, b=15)  # pyright: ignore
+assert result2 == 20, 'async function should handle keyword arguments'

package/ref-monty/crates/monty/test_cases/attr__get_int_error.py

@@ -0,0 +1,9 @@
+x = 5
+x.foo
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "attr__get_int_error.py", line 2, in <module>
+    x.foo
+AttributeError: 'int' object has no attribute 'foo'
+"""

package/ref-monty/crates/monty/test_cases/attr__get_list_error.py

@@ -0,0 +1,9 @@
+x = [1, 2, 3]
+x.foo
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "attr__get_list_error.py", line 2, in <module>
+    x.foo
+AttributeError: 'list' object has no attribute 'foo'
+"""

package/ref-monty/crates/monty/test_cases/attr__set_frozen_nonfield.py

@@ -0,0 +1,12 @@
+# call-external
+# Test that setting a non-field attribute on frozen dataclass raises error
+point = make_point()
+point.z = 42
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "attr__set_frozen_nonfield.py", line 4, in <module>
+    point.z = 42
+    ~~~~~~~
+FrozenInstanceError: cannot assign to field 'z'
+"""

package/ref-monty/crates/monty/test_cases/attr__set_int_error.py

@@ -0,0 +1,10 @@
+x = 5
+x.foo = 1
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "attr__set_int_error.py", line 2, in <module>
+    x.foo = 1
+    ~~~~~
+AttributeError: 'int' object has no attribute 'foo' and no __dict__ for setting new attributes
+"""